From 5125ae12e9194d6de810e4dfa9dea2eb91b20017 Mon Sep 17 00:00:00 2001
From: y <konstantinos.parasyris@intel.com>
Date: Fri, 10 Apr 2026 09:53:48 -0700
Subject: [PATCH 01/11] [SYCL] Add lightweight free-function kernel property
 headers

Introduce lightweight kernel-property headers for free-function kernel
annotation and launch-tuning use cases:

- function_properties.hpp provides a standalone path for execution-kind
  annotations such as nd_range_kernel and single_task_kernel.
- function_launch_properties.hpp provides a lightweight path for launch
  properties such as work_group_size, work_group_size_hint, and
  sub_group_size.
- kernel_properties/properties.hpp remains the umbrella path for full
  property-list semantics and cross-property conflict checking.

This reduces compile-time cost for kernel-language and JIT-style usage
while preserving the full umbrella interface for users who need complete
property-list behavior.

Measured header compile times:
- function_properties.hpp: ~26 ms
- function_launch_properties path: ~58 ms
- kernel_properties/properties.hpp umbrella: ~68 ms
---
 ..._ext_oneapi_free_function_kernels.asciidoc |  37 ++
 ...sycl_ext_oneapi_kernel_properties.asciidoc |  34 ++
 .../oneapi/experimental/virtual_functions.hpp |  23 ++
 .../function_launch_properties.hpp            | 329 ++++++++++++++++++
 .../kernel_properties/function_properties.hpp |  98 ++++++
 .../oneapi/kernel_properties/properties.hpp   | 252 +-------------
 .../invalid_compile_time_properties.cpp       |   6 +-
 .../properties/properties_kernel.cpp          |  33 +-
 .../properties/properties_kernel_negative.cpp | 100 +++---
 .../include_deps/sycl_detail_core.hpp.cpp     |   6 +-
 .../sycl_khr_includes_handler.hpp.cpp         |   2 +
 .../sycl_khr_includes_kernel_bundle.hpp.cpp   |   2 +
 .../sycl_khr_includes_queue.hpp.cpp           |   6 +-
 .../sycl_khr_includes_reduction.hpp.cpp       |   2 +
 .../sycl_khr_includes_stream.hpp.cpp          |   2 +
 .../sycl_khr_includes_usm.hpp.cpp             |   6 +-
 16 files changed, 630 insertions(+), 308 deletions(-)
 create mode 100644 sycl/include/sycl/ext/oneapi/kernel_properties/function_launch_properties.hpp
 create mode 100644 sycl/include/sycl/ext/oneapi/kernel_properties/function_properties.hpp

diff --git a/sycl/doc/extensions/experimental/sycl_ext_oneapi_free_function_kernels.asciidoc b/sycl/doc/extensions/experimental/sycl_ext_oneapi_free_function_kernels.asciidoc
index 5ef1c663ee431..3359b3e0be1b4 100644
--- a/sycl/doc/extensions/experimental/sycl_ext_oneapi_free_function_kernels.asciidoc
+++ b/sycl/doc/extensions/experimental/sycl_ext_oneapi_free_function_kernels.asciidoc
@@ -112,6 +112,36 @@ supports.
  feature-test macro always has this value.
 |===
 
+=== Headers
+
+In the {dpcpp} implementation, applications that use this extension have a
+choice of headers depending on which properties they need:
+
+* `#include <sycl/ext/oneapi/kernel_properties/function_properties.hpp>` is
+  sufficient for `SYCL_EXT_ONEAPI_FUNCTION_PROPERTY`,
+  `nd_range_kernel<Dims>`, and `single_task_kernel`.
+
+* `#include <sycl/ext/oneapi/kernel_properties/function_launch_properties.hpp>`
+  additionally provides the launch-configuration properties that may be applied
+  directly to a free function kernel declaration, such as
+  `work_group_size`, `work_group_size_hint`, `sub_group_size`,
+  `max_work_group_size`, and `max_linear_work_group_size`.
+
+* `#include <sycl/ext/oneapi/kernel_properties/properties.hpp>` provides the
+  full kernel properties interface, including property lists such as
+  `properties{...}` and embedded kernel properties via `properties_tag`.
+
+Applications may include the umbrella header in all cases. The lighter-weight
+headers are intended for code that only needs function annotations on free
+function kernels and where reducing compile time is a priority.
+
+The lighter-weight headers retain validation of each individual property, such
+as arity and non-zero size requirements, but they do not provide the
+cross-property validation that is performed when properties are combined via
+the full property-list machinery. For example, checks for conflicting
+combinations such as `work_group_size` together with `max_work_group_size` are
+available only through the umbrella header.
+
 === Defining a free function kernel
 
 A free function kernel is a normal C++ function definition, where the function
@@ -803,6 +833,13 @@ in link:../experimental/sycl_ext_oneapi_kernel_properties.asciidoc[
 sycl_ext_oneapi_kernel_properties] by applying the properties to the function
 declaration as illustrated below.
 
+In the {dpcpp} implementation, code that uses only function annotations may
+include either `function_properties.hpp` or
+`function_launch_properties.hpp` instead of the full
+`kernel_properties/properties.hpp` header. Applications that need property-list
+semantics, including cross-property validation, should include the umbrella
+header.
+
 ```
 SYCL_EXT_ONEAPI_FUNCTION_PROPERTY((syclexp::nd_range_kernel<1>))
 SYCL_EXT_ONEAPI_FUNCTION_PROPERTY((syclexp::work_group_size<32>))
diff --git a/sycl/doc/extensions/experimental/sycl_ext_oneapi_kernel_properties.asciidoc b/sycl/doc/extensions/experimental/sycl_ext_oneapi_kernel_properties.asciidoc
index 341a1473d33b5..a36020e31bba4 100644
--- a/sycl/doc/extensions/experimental/sycl_ext_oneapi_kernel_properties.asciidoc
+++ b/sycl/doc/extensions/experimental/sycl_ext_oneapi_kernel_properties.asciidoc
@@ -115,6 +115,40 @@ supports.
  feature-test macro always has this value.
 |===
 
+=== Headers
+
+In the {dpcpp} implementation, the full API described in this extension is
+provided by:
+
+* `#include <sycl/ext/oneapi/kernel_properties/properties.hpp>`
+
+This umbrella header should be used when code needs property lists such as
+`properties{...}`, embedded kernel properties via `properties_tag`, or any of
+the non-launch kernel properties described in this extension.
+
+The implementation also provides lighter-weight headers for code that only
+needs free-function annotations:
+
+* `#include <sycl/ext/oneapi/kernel_properties/function_properties.hpp>` for
+  `nd_range_kernel<Dims>`, `single_task_kernel`, and
+  `SYCL_EXT_ONEAPI_FUNCTION_PROPERTY`.
+
+* `#include <sycl/ext/oneapi/kernel_properties/function_launch_properties.hpp>`
+  for the launch-configuration properties that can be applied directly to free
+  function declarations, including `work_group_size`,
+  `work_group_size_hint`, `sub_group_size`, `max_work_group_size`, and
+  `max_linear_work_group_size`.
+
+These lighter-weight headers are primarily intended for code paths where
+reduced compile time is a high priority and the application only needs
+function-level annotations.
+
+They retain validation of each individual property, but they do not provide
+the cross-property validation that depends on forming a full property list.
+For example, checks for conflicting combinations such as `work_group_size`
+together with `max_work_group_size` or `max_linear_work_group_size` are
+performed only when using the umbrella header.
+
 === Kernel Properties
 
 The kernel properties below correspond to kernel attributes defined in
diff --git a/sycl/include/sycl/ext/oneapi/experimental/virtual_functions.hpp b/sycl/include/sycl/ext/oneapi/experimental/virtual_functions.hpp
index 9b13f6e3ed123..4ac20d852ec81 100644
--- a/sycl/include/sycl/ext/oneapi/experimental/virtual_functions.hpp
+++ b/sycl/include/sycl/ext/oneapi/experimental/virtual_functions.hpp
@@ -1,5 +1,6 @@
 #pragma once
 
+#include <sycl/ext/oneapi/kernel_properties/function_properties.hpp>
 #include <sycl/ext/oneapi/properties/property.hpp>
 #include <sycl/ext/oneapi/properties/property_utils.hpp>
 #include <sycl/ext/oneapi/properties/property_value.hpp>
@@ -49,6 +50,17 @@ struct PropertyMetaInfo<indirectly_callable_key::value_t<Set>> {
 #endif
 };
 
+template <typename Set>
+struct FunctionPropertyMetaInfo<indirectly_callable_key::value_t<Set>> {
+  static constexpr const char *name = "indirectly-callable";
+  static constexpr const char *value =
+#ifdef __SYCL_DEVICE_ONLY__
+      __builtin_sycl_unique_stable_name(Set);
+#else
+      "";
+#endif
+};
+
 #ifdef __SYCL_DEVICE_ONLY__
 // Helper to concatenate several lists of characters into a single string.
 // Lists are separated from each other with comma within the resulting string.
@@ -105,6 +117,17 @@ struct PropertyMetaInfo<calls_indirectly_key::value_t<SetIds...>> {
 #endif
 };
 
+template <typename... SetIds>
+struct FunctionPropertyMetaInfo<calls_indirectly_key::value_t<SetIds...>> {
+  static constexpr const char *name = "calls-indirectly";
+  static constexpr const char *value =
+#ifdef __SYCL_DEVICE_ONLY__
+      UniqueStableNameListStr<SetIds...>::value;
+#else
+      "";
+#endif
+};
+
 } // namespace detail
 
 } // namespace ext::oneapi::experimental
diff --git a/sycl/include/sycl/ext/oneapi/kernel_properties/function_launch_properties.hpp b/sycl/include/sycl/ext/oneapi/kernel_properties/function_launch_properties.hpp
new file mode 100644
index 0000000000000..94fe9124145f0
--- /dev/null
+++ b/sycl/include/sycl/ext/oneapi/kernel_properties/function_launch_properties.hpp
@@ -0,0 +1,329 @@
+//==--- function_launch_properties.hpp - SYCL function launch properties --==//
+//
+// 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
+
+// This header extends the split kernel-property path with launch-tuning
+// annotations. Keep these public property_value definitions local to this split
+// header so the umbrella include reuses the same types and preserves
+// decltype(...) identity without pulling the full kernel-properties machinery
+// into standalone launch-property use.
+
+#include <array>
+#include <stddef.h>
+#include <stdint.h>
+
+#include <sycl/ext/oneapi/kernel_properties/function_properties.hpp>
+#include <sycl/ext/oneapi/properties/property_value.hpp>
+
+namespace sycl {
+inline namespace _V1 {
+namespace ext::oneapi::experimental {
+namespace detail {
+
+template <typename PropKey, typename Properties> struct ConflictingProperties;
+
+template <size_t... Xs> struct LaunchAllNonZero {
+  static constexpr bool value = true;
+};
+template <size_t X, size_t... Xs> struct LaunchAllNonZero<X, Xs...> {
+  static constexpr bool value = X > 0 && LaunchAllNonZero<Xs...>::value;
+};
+
+inline constexpr size_t LaunchDecimalBase = 10;
+
+template <size_t... Sizes> struct LaunchSizeList {};
+template <char... Chars> struct LaunchCharList {};
+
+template <char... Chars> struct LaunchCharsToStr {
+  static constexpr const char value[] = {Chars..., '\0'};
+};
+
+template <typename List, typename ParsedList, char... Chars>
+struct LaunchSizeListToStrHelper;
+
+template <size_t Value, size_t... Values, char... ParsedChars, char... Chars>
+struct LaunchSizeListToStrHelper<LaunchSizeList<Value, Values...>,
+                                 LaunchCharList<ParsedChars...>, Chars...>
+    : LaunchSizeListToStrHelper<
+          LaunchSizeList<Value / LaunchDecimalBase, Values...>,
+          LaunchCharList<ParsedChars...>, '0' + (Value % LaunchDecimalBase),
+          Chars...> {};
+
+template <size_t... Values, char... ParsedChars, char... Chars>
+struct LaunchSizeListToStrHelper<LaunchSizeList<0, Values...>,
+                                 LaunchCharList<ParsedChars...>, Chars...>
+    : LaunchSizeListToStrHelper<LaunchSizeList<Values...>,
+                                LaunchCharList<ParsedChars..., Chars..., ','>> {
+};
+
+template <size_t... Values, char... ParsedChars>
+struct LaunchSizeListToStrHelper<LaunchSizeList<0, Values...>,
+                                 LaunchCharList<ParsedChars...>>
+    : LaunchSizeListToStrHelper<LaunchSizeList<Values...>,
+                                LaunchCharList<ParsedChars..., '0', ','>> {};
+
+template <char... ParsedChars, char... Chars>
+struct LaunchSizeListToStrHelper<LaunchSizeList<0>,
+                                 LaunchCharList<ParsedChars...>, Chars...>
+    : LaunchCharsToStr<ParsedChars..., Chars...> {};
+
+template <char... ParsedChars>
+struct LaunchSizeListToStrHelper<LaunchSizeList<0>,
+                                 LaunchCharList<ParsedChars...>>
+    : LaunchCharsToStr<ParsedChars..., '0'> {};
+
+template <>
+struct LaunchSizeListToStrHelper<LaunchSizeList<>, LaunchCharList<>>
+    : LaunchCharsToStr<> {};
+
+template <size_t... Sizes>
+struct LaunchSizeListToStr
+    : LaunchSizeListToStrHelper<LaunchSizeList<Sizes...>, LaunchCharList<>> {};
+
+} // namespace detail
+
+struct work_group_size_key
+    : detail::compile_time_property_key<detail::PropKind::WorkGroupSize> {
+  template <size_t... Dims>
+  using value_t = property_value<work_group_size_key,
+                                 std::integral_constant<size_t, Dims>...>;
+};
+
+struct work_group_size_hint_key
+    : detail::compile_time_property_key<detail::PropKind::WorkGroupSizeHint> {
+  template <size_t... Dims>
+  using value_t = property_value<work_group_size_hint_key,
+                                 std::integral_constant<size_t, Dims>...>;
+};
+
+struct sub_group_size_key
+    : detail::compile_time_property_key<detail::PropKind::SubGroupSize> {
+  template <uint32_t Size>
+  using value_t = property_value<sub_group_size_key,
+                                 std::integral_constant<uint32_t, Size>>;
+};
+
+struct max_work_group_size_key
+    : detail::compile_time_property_key<detail::PropKind::MaxWorkGroupSize> {
+  template <size_t... Dims>
+  using value_t = property_value<max_work_group_size_key,
+                                 std::integral_constant<size_t, Dims>...>;
+};
+
+struct max_linear_work_group_size_key
+    : detail::compile_time_property_key<
+          detail::PropKind::MaxLinearWorkGroupSize> {
+  template <size_t Size>
+  using value_t = property_value<max_linear_work_group_size_key,
+                                 std::integral_constant<size_t, Size>>;
+};
+
+template <size_t Dim0, size_t... Dims>
+struct property_value<work_group_size_key, std::integral_constant<size_t, Dim0>,
+                      std::integral_constant<size_t, Dims>...>
+    : detail::property_base<
+          property_value<work_group_size_key,
+                         std::integral_constant<size_t, Dim0>,
+                         std::integral_constant<size_t, Dims>...>,
+          detail::PropKind::WorkGroupSize, work_group_size_key> {
+  static_assert(
+      sizeof...(Dims) + 1 <= 3,
+      "work_group_size property currently only supports up to three values.");
+  static_assert(detail::LaunchAllNonZero<Dim0, Dims...>::value,
+                "work_group_size property must only contain non-zero values.");
+
+  constexpr size_t operator[](int Dim) const {
+    return std::array<size_t, sizeof...(Dims) + 1>{Dim0, Dims...}[Dim];
+  }
+
+private:
+  constexpr size_t size() const { return sizeof...(Dims) + 1; }
+
+  template <typename, typename> friend struct detail::ConflictingProperties;
+};
+
+template <size_t Dim0, size_t... Dims>
+struct property_value<work_group_size_hint_key,
+                      std::integral_constant<size_t, Dim0>,
+                      std::integral_constant<size_t, Dims>...>
+    : detail::property_base<
+          property_value<work_group_size_hint_key,
+                         std::integral_constant<size_t, Dim0>,
+                         std::integral_constant<size_t, Dims>...>,
+          detail::PropKind::WorkGroupSizeHint, work_group_size_hint_key> {
+  static_assert(sizeof...(Dims) + 1 <= 3,
+                "work_group_size_hint property currently only supports up to "
+                "three values.");
+  static_assert(
+      detail::LaunchAllNonZero<Dim0, Dims...>::value,
+      "work_group_size_hint property must only contain non-zero values.");
+
+  constexpr size_t operator[](int Dim) const {
+    return std::array<size_t, sizeof...(Dims) + 1>{Dim0, Dims...}[Dim];
+  }
+};
+
+template <uint32_t Size>
+struct property_value<sub_group_size_key,
+                      std::integral_constant<uint32_t, Size>>
+    : detail::property_base<
+          property_value<sub_group_size_key,
+                         std::integral_constant<uint32_t, Size>>,
+          detail::PropKind::SubGroupSize, sub_group_size_key> {
+  static_assert(Size != 0,
+                "sub_group_size property must contain a non-zero value.");
+
+  using value_t = std::integral_constant<uint32_t, Size>;
+  static constexpr uint32_t value = Size;
+};
+
+template <size_t Dim0, size_t... Dims>
+struct property_value<max_work_group_size_key,
+                      std::integral_constant<size_t, Dim0>,
+                      std::integral_constant<size_t, Dims>...>
+    : detail::property_base<
+          property_value<max_work_group_size_key,
+                         std::integral_constant<size_t, Dim0>,
+                         std::integral_constant<size_t, Dims>...>,
+          detail::PropKind::MaxWorkGroupSize, max_work_group_size_key> {
+  static_assert(
+      sizeof...(Dims) + 1 <= 3,
+      "max_work_group_size currently only supports up to three values.");
+  static_assert(detail::LaunchAllNonZero<Dim0, Dims...>::value,
+                "max_work_group_size must only contain non-zero values.");
+
+  constexpr size_t operator[](int Dim) const {
+    return std::array<size_t, sizeof...(Dims) + 1>{Dim0, Dims...}[Dim];
+  }
+
+private:
+  constexpr size_t size() const { return sizeof...(Dims) + 1; }
+
+  template <typename, typename> friend struct detail::ConflictingProperties;
+};
+
+template <size_t Size>
+struct property_value<max_linear_work_group_size_key,
+                      std::integral_constant<size_t, Size>>
+    : detail::property_base<
+          property_value<max_linear_work_group_size_key,
+                         std::integral_constant<size_t, Size>>,
+          detail::PropKind::MaxLinearWorkGroupSize,
+          max_linear_work_group_size_key> {
+  static_assert(Size != 0,
+                "max_linear_work_group_size must contain a non-zero value.");
+
+  using value_t = std::integral_constant<size_t, Size>;
+  static constexpr size_t value = Size;
+};
+
+namespace detail {
+
+template <size_t... Dims>
+struct HasCompileTimeEffect<work_group_size_key::value_t<Dims...>>
+    : std::true_type {};
+template <size_t... Dims>
+struct HasCompileTimeEffect<work_group_size_hint_key::value_t<Dims...>>
+    : std::true_type {};
+template <uint32_t Size>
+struct HasCompileTimeEffect<sub_group_size_key::value_t<Size>>
+    : std::true_type {};
+template <size_t... Dims>
+struct HasCompileTimeEffect<max_work_group_size_key::value_t<Dims...>>
+    : std::true_type {};
+template <size_t Size>
+struct HasCompileTimeEffect<max_linear_work_group_size_key::value_t<Size>>
+    : std::true_type {};
+
+template <size_t Dim0, size_t... Dims>
+struct PropertyMetaInfo<work_group_size_key::value_t<Dim0, Dims...>> {
+  static constexpr const char *name = "sycl-work-group-size";
+  static constexpr const char *value =
+      LaunchSizeListToStr<Dim0, Dims...>::value;
+};
+template <size_t Dim0, size_t... Dims>
+struct FunctionPropertyMetaInfo<work_group_size_key::value_t<Dim0, Dims...>> {
+  static constexpr const char *name = "sycl-work-group-size";
+  static constexpr const char *value =
+      LaunchSizeListToStr<Dim0, Dims...>::value;
+};
+
+template <size_t Dim0, size_t... Dims>
+struct PropertyMetaInfo<work_group_size_hint_key::value_t<Dim0, Dims...>> {
+  static constexpr const char *name = "sycl-work-group-size-hint";
+  static constexpr const char *value =
+      LaunchSizeListToStr<Dim0, Dims...>::value;
+};
+template <size_t Dim0, size_t... Dims>
+struct FunctionPropertyMetaInfo<
+    work_group_size_hint_key::value_t<Dim0, Dims...>> {
+  static constexpr const char *name = "sycl-work-group-size-hint";
+  static constexpr const char *value =
+      LaunchSizeListToStr<Dim0, Dims...>::value;
+};
+
+template <uint32_t Size>
+struct PropertyMetaInfo<sub_group_size_key::value_t<Size>> {
+  static constexpr const char *name = "sycl-sub-group-size";
+  static constexpr uint32_t value = Size;
+};
+template <uint32_t Size>
+struct FunctionPropertyMetaInfo<sub_group_size_key::value_t<Size>> {
+  static constexpr const char *name = "sycl-sub-group-size";
+  static constexpr uint32_t value = Size;
+};
+
+template <size_t Dim0, size_t... Dims>
+struct PropertyMetaInfo<max_work_group_size_key::value_t<Dim0, Dims...>> {
+  static constexpr const char *name = "sycl-max-work-group-size";
+  static constexpr const char *value =
+      LaunchSizeListToStr<Dim0, Dims...>::value;
+};
+template <size_t Dim0, size_t... Dims>
+struct FunctionPropertyMetaInfo<
+    max_work_group_size_key::value_t<Dim0, Dims...>> {
+  static constexpr const char *name = "sycl-max-work-group-size";
+  static constexpr const char *value =
+      LaunchSizeListToStr<Dim0, Dims...>::value;
+};
+
+template <size_t Size>
+struct PropertyMetaInfo<max_linear_work_group_size_key::value_t<Size>> {
+  static constexpr const char *name = "sycl-max-linear-work-group-size";
+  static constexpr size_t value = Size;
+};
+template <size_t Size>
+struct FunctionPropertyMetaInfo<max_linear_work_group_size_key::value_t<Size>> {
+  static constexpr const char *name = "sycl-max-linear-work-group-size";
+  static constexpr size_t value = Size;
+};
+
+} // namespace detail
+
+template <size_t Dim0, size_t... Dims>
+inline constexpr work_group_size_key::value_t<Dim0, Dims...> work_group_size;
+
+template <size_t Dim0, size_t... Dims>
+inline constexpr work_group_size_hint_key::value_t<Dim0, Dims...>
+    work_group_size_hint;
+
+template <uint32_t Size>
+inline constexpr sub_group_size_key::value_t<Size> sub_group_size;
+
+template <size_t Dim0, size_t... Dims>
+inline constexpr max_work_group_size_key::value_t<Dim0, Dims...>
+    max_work_group_size;
+
+template <size_t Size>
+inline constexpr max_linear_work_group_size_key::value_t<Size>
+    max_linear_work_group_size;
+
+} // namespace ext::oneapi::experimental
+} // namespace _V1
+} // namespace sycl
\ No newline at end of file
diff --git a/sycl/include/sycl/ext/oneapi/kernel_properties/function_properties.hpp b/sycl/include/sycl/ext/oneapi/kernel_properties/function_properties.hpp
new file mode 100644
index 0000000000000..1b8a133e05b9d
--- /dev/null
+++ b/sycl/include/sycl/ext/oneapi/kernel_properties/function_properties.hpp
@@ -0,0 +1,98 @@
+//==--- function_properties.hpp - SYCL standalone function properties -----==//
+//
+// 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
+
+// This header is the lightweight split entry point for free-function kernel
+// annotations. Keep the public property_value definitions here, rather than
+// only in kernel_properties/properties.hpp, so standalone users and umbrella
+// users observe the same decltype(...) while avoiding the heavier property-list
+// machinery on this path.
+
+#include <sycl/ext/oneapi/properties/property_value.hpp>
+
+#include <type_traits>
+
+namespace sycl {
+inline namespace _V1 {
+namespace ext::oneapi::experimental {
+namespace detail {
+
+template <typename T>
+using remove_cvref_t = std::remove_cv_t<std::remove_reference_t<T>>;
+
+template <typename PropertyT> struct FunctionPropertyMetaInfo;
+
+} // namespace detail
+
+struct nd_range_kernel_key
+    : detail::compile_time_property_key<detail::PropKind::NDRangeKernel> {
+  template <int Dims>
+  using value_t =
+      property_value<nd_range_kernel_key, std::integral_constant<int, Dims>>;
+};
+
+struct single_task_kernel_key
+    : detail::compile_time_property_key<detail::PropKind::SingleTaskKernel> {
+  using value_t = property_value<single_task_kernel_key>;
+};
+
+template <int Dims>
+struct property_value<nd_range_kernel_key, std::integral_constant<int, Dims>>
+    : detail::property_base<property_value<nd_range_kernel_key,
+                                           std::integral_constant<int, Dims>>,
+                            detail::PropKind::NDRangeKernel,
+                            nd_range_kernel_key> {
+  static_assert(Dims >= 1 && Dims <= 3,
+                "nd_range_kernel must use dimension 1, 2, or 3.");
+
+  using value_t = int;
+  static constexpr int dimensions = Dims;
+};
+
+template <>
+struct property_value<single_task_kernel_key>
+    : detail::property_base<property_value<single_task_kernel_key>,
+                            detail::PropKind::SingleTaskKernel,
+                            single_task_kernel_key> {};
+
+template <int Dims>
+inline constexpr nd_range_kernel_key::value_t<Dims> nd_range_kernel;
+
+inline constexpr single_task_kernel_key::value_t single_task_kernel;
+
+namespace detail {
+
+template <int Dims>
+struct FunctionPropertyMetaInfo<nd_range_kernel_key::value_t<Dims>> {
+  static constexpr const char *name = "sycl-nd-range-kernel";
+  static constexpr int value = Dims;
+};
+
+template <> struct FunctionPropertyMetaInfo<single_task_kernel_key::value_t> {
+  static constexpr const char *name = "sycl-single-task-kernel";
+  static constexpr int value = 0;
+};
+
+} // namespace detail
+} // namespace ext::oneapi::experimental
+} // namespace _V1
+} // namespace sycl
+
+#ifdef __SYCL_DEVICE_ONLY__
+#define SYCL_EXT_ONEAPI_FUNCTION_PROPERTY(PROP)                                \
+  [[__sycl_detail__::add_ir_attributes_function(                               \
+      sycl::ext::oneapi::experimental::detail::FunctionPropertyMetaInfo<       \
+          sycl::ext::oneapi::experimental::detail::remove_cvref_t<             \
+              decltype(PROP)>>::name,                                          \
+      sycl::ext::oneapi::experimental::detail::FunctionPropertyMetaInfo<       \
+          sycl::ext::oneapi::experimental::detail::remove_cvref_t<             \
+              decltype(PROP)>>::value)]]
+#else
+#define SYCL_EXT_ONEAPI_FUNCTION_PROPERTY(PROP)
+#endif
\ No newline at end of file
diff --git a/sycl/include/sycl/ext/oneapi/kernel_properties/properties.hpp b/sycl/include/sycl/ext/oneapi/kernel_properties/properties.hpp
index defb1589679b9..16cf6aed572b8 100644
--- a/sycl/include/sycl/ext/oneapi/kernel_properties/properties.hpp
+++ b/sycl/include/sycl/ext/oneapi/kernel_properties/properties.hpp
@@ -13,45 +13,16 @@
 #include <stdint.h>                                          // for uint32_t
 #include <sycl/aspects.hpp>                                  // for aspect
 #include <sycl/ext/oneapi/experimental/forward_progress.hpp> // for forward_progress_guarantee enum
+#include <sycl/ext/oneapi/kernel_properties/function_launch_properties.hpp>
 #include <sycl/ext/oneapi/properties/properties.hpp>
 #include <type_traits>                                   // for true_type
 #include <utility>                                       // for declval
 namespace sycl {
 inline namespace _V1 {
 namespace ext::oneapi::experimental {
-namespace detail {
-// Trait for checking that all size_t values are non-zero.
-template <size_t... Xs> struct AllNonZero {
-  static constexpr bool value = true;
-};
-template <size_t X, size_t... Xs> struct AllNonZero<X, Xs...> {
-  static constexpr bool value = X > 0 && AllNonZero<Xs...>::value;
-};
-} // namespace detail
 
 struct properties_tag {};
 
-struct work_group_size_key
-    : detail::compile_time_property_key<detail::PropKind::WorkGroupSize> {
-  template <size_t... Dims>
-  using value_t = property_value<work_group_size_key,
-                                 std::integral_constant<size_t, Dims>...>;
-};
-
-struct work_group_size_hint_key
-    : detail::compile_time_property_key<detail::PropKind::WorkGroupSizeHint> {
-  template <size_t... Dims>
-  using value_t = property_value<work_group_size_hint_key,
-                                 std::integral_constant<size_t, Dims>...>;
-};
-
-struct sub_group_size_key
-    : detail::compile_time_property_key<detail::PropKind::SubGroupSize> {
-  template <uint32_t Size>
-  using value_t = property_value<sub_group_size_key,
-                                 std::integral_constant<uint32_t, Size>>;
-};
-
 struct device_has_key
     : detail::compile_time_property_key<detail::PropKind::DeviceHas> {
   template <aspect... Aspects>
@@ -59,92 +30,6 @@ struct device_has_key
                                  std::integral_constant<aspect, Aspects>...>;
 };
 
-struct nd_range_kernel_key
-    : detail::compile_time_property_key<detail::PropKind::NDRangeKernel> {
-  template <int Dims>
-  using value_t =
-      property_value<nd_range_kernel_key, std::integral_constant<int, Dims>>;
-};
-
-struct single_task_kernel_key
-    : detail::compile_time_property_key<detail::PropKind::SingleTaskKernel> {
-  using value_t = property_value<single_task_kernel_key>;
-};
-
-struct max_work_group_size_key
-    : detail::compile_time_property_key<detail::PropKind::MaxWorkGroupSize> {
-  template <size_t... Dims>
-  using value_t = property_value<max_work_group_size_key,
-                                 std::integral_constant<size_t, Dims>...>;
-};
-
-struct max_linear_work_group_size_key
-    : detail::compile_time_property_key<
-          detail::PropKind::MaxLinearWorkGroupSize> {
-  template <size_t Size>
-  using value_t = property_value<max_linear_work_group_size_key,
-                                 std::integral_constant<size_t, Size>>;
-};
-
-template <size_t Dim0, size_t... Dims>
-struct property_value<work_group_size_key, std::integral_constant<size_t, Dim0>,
-                      std::integral_constant<size_t, Dims>...>
-    : detail::property_base<
-          property_value<work_group_size_key,
-                         std::integral_constant<size_t, Dim0>,
-                         std::integral_constant<size_t, Dims>...>,
-          detail::PropKind::WorkGroupSize, work_group_size_key> {
-  static_assert(
-      sizeof...(Dims) + 1 <= 3,
-      "work_group_size property currently only supports up to three values.");
-  static_assert(detail::AllNonZero<Dim0, Dims...>::value,
-                "work_group_size property must only contain non-zero values.");
-
-  constexpr size_t operator[](int Dim) const {
-    return std::array<size_t, sizeof...(Dims) + 1>{Dim0, Dims...}[Dim];
-  }
-
-private:
-  constexpr size_t size() const { return sizeof...(Dims) + 1; }
-
-  template <typename, typename> friend struct detail::ConflictingProperties;
-};
-
-template <size_t Dim0, size_t... Dims>
-struct property_value<work_group_size_hint_key,
-                      std::integral_constant<size_t, Dim0>,
-                      std::integral_constant<size_t, Dims>...>
-    : detail::property_base<
-          property_value<work_group_size_hint_key,
-                         std::integral_constant<size_t, Dim0>,
-                         std::integral_constant<size_t, Dims>...>,
-          detail::PropKind::WorkGroupSizeHint, work_group_size_hint_key> {
-  static_assert(sizeof...(Dims) + 1 <= 3,
-                "work_group_size_hint property currently "
-                "only supports up to three values.");
-  static_assert(
-      detail::AllNonZero<Dim0, Dims...>::value,
-      "work_group_size_hint property must only contain non-zero values.");
-
-  constexpr size_t operator[](int Dim) const {
-    return std::array<size_t, sizeof...(Dims) + 1>{Dim0, Dims...}[Dim];
-  }
-};
-
-template <uint32_t Size>
-struct property_value<sub_group_size_key,
-                      std::integral_constant<uint32_t, Size>>
-    : detail::property_base<
-          property_value<sub_group_size_key,
-                         std::integral_constant<uint32_t, Size>>,
-          detail::PropKind::SubGroupSize, sub_group_size_key> {
-  static_assert(Size != 0,
-                "sub_group_size_key property must contain a non-zero value.");
-
-  using value_t = std::integral_constant<uint32_t, Size>;
-  static constexpr uint32_t value = Size;
-};
-
 template <aspect... Aspects>
 struct property_value<device_has_key,
                       std::integral_constant<aspect, Aspects>...>
@@ -155,84 +40,9 @@ struct property_value<device_has_key,
   static constexpr std::array<aspect, sizeof...(Aspects)> value{Aspects...};
 };
 
-template <int Dims>
-struct property_value<nd_range_kernel_key, std::integral_constant<int, Dims>>
-    : detail::property_base<property_value<nd_range_kernel_key,
-                                           std::integral_constant<int, Dims>>,
-                            detail::PropKind::NDRangeKernel,
-                            nd_range_kernel_key> {
-  static_assert(
-      Dims >= 1 && Dims <= 3,
-      "nd_range_kernel_key property must use dimension of 1, 2 or 3.");
-
-  using value_t = int;
-  static constexpr int dimensions = Dims;
-};
-
-template <>
-struct property_value<single_task_kernel_key>
-    : detail::property_base<property_value<single_task_kernel_key>,
-                            detail::PropKind::SingleTaskKernel,
-                            single_task_kernel_key> {};
-
-template <size_t Dim0, size_t... Dims>
-struct property_value<max_work_group_size_key,
-                      std::integral_constant<size_t, Dim0>,
-                      std::integral_constant<size_t, Dims>...>
-    : detail::property_base<
-          property_value<max_work_group_size_key,
-                         std::integral_constant<size_t, Dim0>,
-                         std::integral_constant<size_t, Dims>...>,
-          detail::PropKind::MaxWorkGroupSize, max_work_group_size_key> {
-  static_assert(sizeof...(Dims) + 1 <= 3,
-                "max_work_group_size property currently "
-                "only supports up to three values.");
-  static_assert(
-      detail::AllNonZero<Dim0, Dims...>::value,
-      "max_work_group_size property must only contain non-zero values.");
-
-  constexpr size_t operator[](int Dim) const {
-    return std::array<size_t, sizeof...(Dims) + 1>{Dim0, Dims...}[Dim];
-  }
-
-private:
-  constexpr size_t size() const { return sizeof...(Dims) + 1; }
-
-  template <typename, typename> friend struct detail::ConflictingProperties;
-};
-
-template <>
-struct property_value<max_linear_work_group_size_key>
-    : detail::property_base<property_value<max_linear_work_group_size_key>,
-                            detail::PropKind::MaxLinearWorkGroupSize,
-                            max_linear_work_group_size_key> {};
-
-template <size_t Dim0, size_t... Dims>
-inline constexpr work_group_size_key::value_t<Dim0, Dims...> work_group_size;
-
-template <size_t Dim0, size_t... Dims>
-inline constexpr work_group_size_hint_key::value_t<Dim0, Dims...>
-    work_group_size_hint;
-
-template <uint32_t Size>
-inline constexpr sub_group_size_key::value_t<Size> sub_group_size;
-
 template <aspect... Aspects>
 inline constexpr device_has_key::value_t<Aspects...> device_has;
 
-template <int Dims>
-inline constexpr nd_range_kernel_key::value_t<Dims> nd_range_kernel;
-
-inline constexpr single_task_kernel_key::value_t single_task_kernel;
-
-template <size_t Dim0, size_t... Dims>
-inline constexpr max_work_group_size_key::value_t<Dim0, Dims...>
-    max_work_group_size;
-
-template <size_t Size>
-inline constexpr max_linear_work_group_size_key::value_t<Size>
-    max_linear_work_group_size;
-
 struct work_group_progress_key
     : detail::compile_time_property_key<detail::PropKind::WorkGroupProgress> {
   template <forward_progress_guarantee Guarantee,
@@ -327,59 +137,20 @@ inline constexpr work_item_progress_key::value_t<Guarantee, CoordinationScope>
     work_item_progress;
 
 namespace detail {
-
-template <size_t... Dims>
-struct HasCompileTimeEffect<work_group_size_key::value_t<Dims...>>
-    : std::true_type {};
-template <size_t... Dims>
-struct HasCompileTimeEffect<work_group_size_hint_key::value_t<Dims...>>
-    : std::true_type {};
-template <uint32_t Size>
-struct HasCompileTimeEffect<sub_group_size_key::value_t<Size>>
-    : std::true_type {};
 template <sycl::aspect... Aspects>
 struct HasCompileTimeEffect<device_has_key::value_t<Aspects...>>
     : std::true_type {};
-
-template <size_t Dim0, size_t... Dims>
-struct PropertyMetaInfo<work_group_size_key::value_t<Dim0, Dims...>> {
-  static constexpr const char *name = "sycl-work-group-size";
-  static constexpr const char *value = SizeListToStr<Dim0, Dims...>::value;
-};
-template <size_t Dim0, size_t... Dims>
-struct PropertyMetaInfo<work_group_size_hint_key::value_t<Dim0, Dims...>> {
-  static constexpr const char *name = "sycl-work-group-size-hint";
-  static constexpr const char *value = SizeListToStr<Dim0, Dims...>::value;
-};
-template <uint32_t Size>
-struct PropertyMetaInfo<sub_group_size_key::value_t<Size>> {
-  static constexpr const char *name = "sycl-sub-group-size";
-  static constexpr uint32_t value = Size;
-};
 template <aspect... Aspects>
 struct PropertyMetaInfo<device_has_key::value_t<Aspects...>> {
   static constexpr const char *name = "sycl-device-has";
   static constexpr const char *value =
       SizeListToStr<static_cast<size_t>(Aspects)...>::value;
 };
-template <int Dims>
-struct PropertyMetaInfo<nd_range_kernel_key::value_t<Dims>> {
-  static constexpr const char *name = "sycl-nd-range-kernel";
-  static constexpr int value = Dims;
-};
-template <> struct PropertyMetaInfo<single_task_kernel_key::value_t> {
-  static constexpr const char *name = "sycl-single-task-kernel";
-  static constexpr int value = 0;
-};
-template <size_t Dim0, size_t... Dims>
-struct PropertyMetaInfo<max_work_group_size_key::value_t<Dim0, Dims...>> {
-  static constexpr const char *name = "sycl-max-work-group-size";
-  static constexpr const char *value = SizeListToStr<Dim0, Dims...>::value;
-};
-template <size_t Size>
-struct PropertyMetaInfo<max_linear_work_group_size_key::value_t<Size>> {
-  static constexpr const char *name = "sycl-max-linear-work-group-size";
-  static constexpr size_t value = Size;
+template <aspect... Aspects>
+struct FunctionPropertyMetaInfo<device_has_key::value_t<Aspects...>> {
+  static constexpr const char *name = "sycl-device-has";
+  static constexpr const char *value =
+      SizeListToStr<static_cast<size_t>(Aspects)...>::value;
 };
 
 template <typename T, typename = void>
@@ -465,14 +236,3 @@ auto RetrieveGetMethodPropertiesOrEmpty(RestT &&...Rest) {
 } // namespace ext::oneapi::experimental
 } // namespace _V1
 } // namespace sycl
-
-#ifdef __SYCL_DEVICE_ONLY__
-#define SYCL_EXT_ONEAPI_FUNCTION_PROPERTY(PROP)                                \
-  [[__sycl_detail__::add_ir_attributes_function(                               \
-      sycl::ext::oneapi::experimental::detail::PropertyMetaInfo<               \
-          std::remove_cv_t<std::remove_reference_t<decltype(PROP)>>>::name,    \
-      sycl::ext::oneapi::experimental::detail::PropertyMetaInfo<               \
-          std::remove_cv_t<std::remove_reference_t<decltype(PROP)>>>::value)]]
-#else
-#define SYCL_EXT_ONEAPI_FUNCTION_PROPERTY(PROP)
-#endif
diff --git a/sycl/test/extensions/annotated_usm/invalid_compile_time_properties.cpp b/sycl/test/extensions/annotated_usm/invalid_compile_time_properties.cpp
index 1210ff0b602c9..d0f2b08845293 100644
--- a/sycl/test/extensions/annotated_usm/invalid_compile_time_properties.cpp
+++ b/sycl/test/extensions/annotated_usm/invalid_compile_time_properties.cpp
@@ -39,7 +39,7 @@ void testInvalidCompileTimeProperty(sycl::queue &q) {
   // expected-error-re@sycl/ext/oneapi/experimental/annotated_usm/alloc_util.hpp:* {{static assertion failed due to requirement {{.+}}device_has_key{{.+}}: Found invalid compile-time property in the property list.}}
   TEST(malloc_device_annotated<int>, N, dev, Ctx, properties{alignment<4>, device_has<sycl::aspect::cpu>})
 
-  // expected-error-re@sycl/ext/oneapi/experimental/annotated_usm/alloc_util.hpp:* {{static assertion failed due to requirement {{.+}}work_group_size_key{{.+}}: Found invalid compile-time property in the property list.}}
+  // expected-error-re@sycl/ext/oneapi/experimental/annotated_usm/alloc_util.hpp:* {{static assertion failed due to requirement {{.+}}property_value<{{.+}}work_group_size_key{{.+}}: Found invalid compile-time property in the property list.}}
   TEST(aligned_alloc_device_annotated, 1, N, q, properties{unaliased, work_group_size<1>})
 
   // expected-error-re@sycl/ext/oneapi/experimental/annotated_usm/alloc_util.hpp:* {{static assertion failed due to requirement {{.+}}baz_key{{.+}}: Found invalid compile-time property in the property list.}}
@@ -87,7 +87,7 @@ void testInvalidCompileTimeProperty(sycl::queue &q) {
   // expected-error-re@sycl/ext/oneapi/experimental/annotated_usm/alloc_util.hpp:* {{static assertion failed due to requirement {{.+}}boo_key{{.+}}: Found invalid compile-time property in the property list.}}
   TEST(aligned_alloc_shared_annotated<int>, 1, N, dev, Ctx, properties{unaliased, alignment<4>, boo<int>})
 
-  // expected-error-re@sycl/ext/oneapi/experimental/annotated_usm/alloc_util.hpp:* {{static assertion failed due to requirement {{.+}}sub_group_size_key{{.+}}: Found invalid compile-time property in the property list.}}
+  // expected-error-re@sycl/ext/oneapi/experimental/annotated_usm/alloc_util.hpp:* {{static assertion failed due to requirement {{.+}}property_value<{{.+}}sub_group_size_key{{.+}}: Found invalid compile-time property in the property list.}}
   TEST(malloc_annotated, N, q, alloc::device, properties{unaliased, sub_group_size<2>})
 
   // expected-error-re@sycl/ext/oneapi/experimental/annotated_usm/alloc_util.hpp:* {{static assertion failed due to requirement {{.+}}boo_key{{.+}}: Found invalid compile-time property in the property list.}}
@@ -96,7 +96,7 @@ void testInvalidCompileTimeProperty(sycl::queue &q) {
   // expected-error-re@sycl/ext/oneapi/experimental/annotated_usm/alloc_util.hpp:* {{static assertion failed due to requirement {{.+}}boo_key{{.+}}: Found invalid compile-time property in the property list.}}
   TEST(aligned_alloc_annotated, 1, N, dev, Ctx, alloc::device, properties{unaliased, boo<bool>})
 
-  // expected-error-re@sycl/ext/oneapi/experimental/annotated_usm/alloc_util.hpp:* {{static assertion failed due to requirement {{.+}}work_group_size_hint_key{{.+}}: Found invalid compile-time property in the property list.}}
+  // expected-error-re@sycl/ext/oneapi/experimental/annotated_usm/alloc_util.hpp:* {{static assertion failed due to requirement {{.+}}property_value<{{.+}}work_group_size_hint_key{{.+}}: Found invalid compile-time property in the property list.}}
   TEST(aligned_alloc_annotated<int>, 1, N, q, alloc::device, properties{unaliased, work_group_size_hint<1>})
 
   // expected-error-re@sycl/ext/oneapi/experimental/annotated_usm/alloc_util.hpp:* {{static assertion failed due to requirement {{.+}}baz_key{{.+}}: Found invalid compile-time property in the property list.}}
diff --git a/sycl/test/extensions/properties/properties_kernel.cpp b/sycl/test/extensions/properties/properties_kernel.cpp
index 86be8c94cf0d4..b5a6df22b28fc 100644
--- a/sycl/test/extensions/properties/properties_kernel.cpp
+++ b/sycl/test/extensions/properties/properties_kernel.cpp
@@ -60,6 +60,36 @@ int main() {
       is_property_value<decltype(max_work_group_size<8, 8, 8>)>::value);
   static_assert(
       is_property_value<decltype(max_linear_work_group_size<8>)>::value);
+  static_assert(
+      std::is_same_v<
+          std::remove_cv_t<decltype(nd_range_kernel<1>)>,
+          property_value<nd_range_kernel_key, std::integral_constant<int, 1>>>);
+  static_assert(std::is_same_v<std::remove_cv_t<decltype(single_task_kernel)>,
+                               property_value<single_task_kernel_key>>);
+  static_assert(
+      std::is_same_v<
+          std::remove_cv_t<decltype(work_group_size<2, 2>)>,
+          property_value<work_group_size_key, std::integral_constant<size_t, 2>,
+                         std::integral_constant<size_t, 2>>>);
+  static_assert(
+      std::is_same_v<std::remove_cv_t<decltype(work_group_size_hint<3, 3, 3>)>,
+                     property_value<work_group_size_hint_key,
+                                    std::integral_constant<size_t, 3>,
+                                    std::integral_constant<size_t, 3>,
+                                    std::integral_constant<size_t, 3>>>);
+  static_assert(
+      std::is_same_v<std::remove_cv_t<decltype(sub_group_size<7>)>,
+                     property_value<sub_group_size_key,
+                                    std::integral_constant<uint32_t, 7>>>);
+  static_assert(
+      std::is_same_v<std::remove_cv_t<decltype(max_work_group_size<8, 8>)>,
+                     property_value<max_work_group_size_key,
+                                    std::integral_constant<size_t, 8>,
+                                    std::integral_constant<size_t, 8>>>);
+  static_assert(
+      std::is_same_v<std::remove_cv_t<decltype(max_linear_work_group_size<8>)>,
+                     property_value<max_linear_work_group_size_key,
+                                    std::integral_constant<size_t, 8>>>);
 
   static_assert(
       std::is_same_v<work_group_size_key, decltype(work_group_size<8>)::key_t>);
@@ -108,9 +138,6 @@ int main() {
   static_assert(max_work_group_size<28, 29, 30>[2] == 30);
   static_assert(max_linear_work_group_size<28>.value == 28);
 
-  static_assert(std::is_same_v<decltype(sub_group_size<28>)::value_t,
-                               std::integral_constant<uint32_t, 28>>);
-
   singleAspectDeviceHasChecks<aspect::cpu>();
   singleAspectDeviceHasChecks<aspect::gpu>();
   singleAspectDeviceHasChecks<aspect::accelerator>();
diff --git a/sycl/test/extensions/properties/properties_kernel_negative.cpp b/sycl/test/extensions/properties/properties_kernel_negative.cpp
index e3c7314182208..27dac354dca74 100644
--- a/sycl/test/extensions/properties/properties_kernel_negative.cpp
+++ b/sycl/test/extensions/properties/properties_kernel_negative.cpp
@@ -30,53 +30,53 @@ void check_work_group_size() {
   // expected-error@+1 {{too few template arguments for variable template 'work_group_size'}}
   auto WGSize0 = sycl::ext::oneapi::experimental::work_group_size<>;
 
-  // expected-error-re@sycl/ext/oneapi/kernel_properties/properties.hpp:* {{static assertion failed due to requirement {{.+}}: work_group_size property must only contain non-zero values.}}
-  // expected-error@sycl/ext/oneapi/kernel_properties/properties.hpp:* {{constexpr variable 'work_group_size<0>' must be initialized by a constant expression}}
+  // expected-error-re@sycl/ext/oneapi/kernel_properties/function_launch_properties.hpp:* {{static assertion failed due to requirement {{.+}}: work_group_size property must only contain non-zero values.}}
+  // expected-error@sycl/ext/oneapi/kernel_properties/function_launch_properties.hpp:* {{constexpr variable 'work_group_size<0>' must be initialized by a constant expression}}
   // expected-note@+1 {{in instantiation of variable template specialization 'sycl::ext::oneapi::experimental::work_group_size<0>' requested here}}
   auto WGSize1 = sycl::ext::oneapi::experimental::work_group_size<0>;
-  // expected-error-re@sycl/ext/oneapi/kernel_properties/properties.hpp:* {{static assertion failed due to requirement {{.+}}: work_group_size property must only contain non-zero values.}}
-  // expected-error@sycl/ext/oneapi/kernel_properties/properties.hpp:* {{constexpr variable 'work_group_size<0, 0>' must be initialized by a constant expression}}
+  // expected-error-re@sycl/ext/oneapi/kernel_properties/function_launch_properties.hpp:* {{static assertion failed due to requirement {{.+}}: work_group_size property must only contain non-zero values.}}
+  // expected-error@sycl/ext/oneapi/kernel_properties/function_launch_properties.hpp:* {{constexpr variable 'work_group_size<0, 0>' must be initialized by a constant expression}}
   // expected-note@+1 {{in instantiation of variable template specialization 'sycl::ext::oneapi::experimental::work_group_size<0, 0>' requested here}}
   auto WGSize2 = sycl::ext::oneapi::experimental::work_group_size<0, 0>;
-  // expected-error-re@sycl/ext/oneapi/kernel_properties/properties.hpp:* {{static assertion failed due to requirement {{.+}}: work_group_size property must only contain non-zero values.}}
-  // expected-error@sycl/ext/oneapi/kernel_properties/properties.hpp:* {{constexpr variable 'work_group_size<1, 0>' must be initialized by a constant expression}}
+  // expected-error-re@sycl/ext/oneapi/kernel_properties/function_launch_properties.hpp:* {{static assertion failed due to requirement {{.+}}: work_group_size property must only contain non-zero values.}}
+  // expected-error@sycl/ext/oneapi/kernel_properties/function_launch_properties.hpp:* {{constexpr variable 'work_group_size<1, 0>' must be initialized by a constant expression}}
   // expected-note@+1 {{in instantiation of variable template specialization 'sycl::ext::oneapi::experimental::work_group_size<1, 0>' requested here}}
   auto WGSize3 = sycl::ext::oneapi::experimental::work_group_size<1, 0>;
-  // expected-error-re@sycl/ext/oneapi/kernel_properties/properties.hpp:* {{static assertion failed due to requirement {{.+}}: work_group_size property must only contain non-zero values.}}
-  // expected-error@sycl/ext/oneapi/kernel_properties/properties.hpp:* {{constexpr variable 'work_group_size<0, 1>' must be initialized by a constant expression}}
+  // expected-error-re@sycl/ext/oneapi/kernel_properties/function_launch_properties.hpp:* {{static assertion failed due to requirement {{.+}}: work_group_size property must only contain non-zero values.}}
+  // expected-error@sycl/ext/oneapi/kernel_properties/function_launch_properties.hpp:* {{constexpr variable 'work_group_size<0, 1>' must be initialized by a constant expression}}
   // expected-note@+1 {{in instantiation of variable template specialization 'sycl::ext::oneapi::experimental::work_group_size<0, 1>' requested here}}
   auto WGSize4 = sycl::ext::oneapi::experimental::work_group_size<0, 1>;
-  // expected-error-re@sycl/ext/oneapi/kernel_properties/properties.hpp:* {{static assertion failed due to requirement {{.+}}: work_group_size property must only contain non-zero values.}}
-  // expected-error@sycl/ext/oneapi/kernel_properties/properties.hpp:* {{constexpr variable 'work_group_size<0, 0, 0>' must be initialized by a constant expression}}
+  // expected-error-re@sycl/ext/oneapi/kernel_properties/function_launch_properties.hpp:* {{static assertion failed due to requirement {{.+}}: work_group_size property must only contain non-zero values.}}
+  // expected-error@sycl/ext/oneapi/kernel_properties/function_launch_properties.hpp:* {{constexpr variable 'work_group_size<0, 0, 0>' must be initialized by a constant expression}}
   // expected-note@+1 {{in instantiation of variable template specialization 'sycl::ext::oneapi::experimental::work_group_size<0, 0, 0>' requested here}}
   auto WGSize5 = sycl::ext::oneapi::experimental::work_group_size<0, 0, 0>;
-  // expected-error-re@sycl/ext/oneapi/kernel_properties/properties.hpp:* {{static assertion failed due to requirement {{.+}}: work_group_size property must only contain non-zero values.}}
-  // expected-error@sycl/ext/oneapi/kernel_properties/properties.hpp:* {{constexpr variable 'work_group_size<1, 0, 0>' must be initialized by a constant expression}}
+  // expected-error-re@sycl/ext/oneapi/kernel_properties/function_launch_properties.hpp:* {{static assertion failed due to requirement {{.+}}: work_group_size property must only contain non-zero values.}}
+  // expected-error@sycl/ext/oneapi/kernel_properties/function_launch_properties.hpp:* {{constexpr variable 'work_group_size<1, 0, 0>' must be initialized by a constant expression}}
   // expected-note@+1 {{in instantiation of variable template specialization 'sycl::ext::oneapi::experimental::work_group_size<1, 0, 0>' requested here}}
   auto WGSize6 = sycl::ext::oneapi::experimental::work_group_size<1, 0, 0>;
-  // expected-error-re@sycl/ext/oneapi/kernel_properties/properties.hpp:* {{static assertion failed due to requirement {{.+}}: work_group_size property must only contain non-zero values.}}
-  // expected-error@sycl/ext/oneapi/kernel_properties/properties.hpp:* {{constexpr variable 'work_group_size<0, 1, 0>' must be initialized by a constant expression}}
+  // expected-error-re@sycl/ext/oneapi/kernel_properties/function_launch_properties.hpp:* {{static assertion failed due to requirement {{.+}}: work_group_size property must only contain non-zero values.}}
+  // expected-error@sycl/ext/oneapi/kernel_properties/function_launch_properties.hpp:* {{constexpr variable 'work_group_size<0, 1, 0>' must be initialized by a constant expression}}
   // expected-note@+1 {{in instantiation of variable template specialization 'sycl::ext::oneapi::experimental::work_group_size<0, 1, 0>' requested here}}
   auto WGSize7 = sycl::ext::oneapi::experimental::work_group_size<0, 1, 0>;
-  // expected-error-re@sycl/ext/oneapi/kernel_properties/properties.hpp:* {{static assertion failed due to requirement {{.+}}: work_group_size property must only contain non-zero values.}}
-  // expected-error@sycl/ext/oneapi/kernel_properties/properties.hpp:* {{constexpr variable 'work_group_size<0, 0, 1>' must be initialized by a constant expression}}
+  // expected-error-re@sycl/ext/oneapi/kernel_properties/function_launch_properties.hpp:* {{static assertion failed due to requirement {{.+}}: work_group_size property must only contain non-zero values.}}
+  // expected-error@sycl/ext/oneapi/kernel_properties/function_launch_properties.hpp:* {{constexpr variable 'work_group_size<0, 0, 1>' must be initialized by a constant expression}}
   // expected-note@+1 {{in instantiation of variable template specialization 'sycl::ext::oneapi::experimental::work_group_size<0, 0, 1>' requested here}}
   auto WGSize8 = sycl::ext::oneapi::experimental::work_group_size<0, 0, 1>;
-  // expected-error-re@sycl/ext/oneapi/kernel_properties/properties.hpp:* {{static assertion failed due to requirement {{.+}}: work_group_size property must only contain non-zero values.}}
-  // expected-error@sycl/ext/oneapi/kernel_properties/properties.hpp:* {{constexpr variable 'work_group_size<1, 1, 0>' must be initialized by a constant expression}}
+  // expected-error-re@sycl/ext/oneapi/kernel_properties/function_launch_properties.hpp:* {{static assertion failed due to requirement {{.+}}: work_group_size property must only contain non-zero values.}}
+  // expected-error@sycl/ext/oneapi/kernel_properties/function_launch_properties.hpp:* {{constexpr variable 'work_group_size<1, 1, 0>' must be initialized by a constant expression}}
   // expected-note@+1 {{in instantiation of variable template specialization 'sycl::ext::oneapi::experimental::work_group_size<1, 1, 0>' requested here}}
   auto WGSize9 = sycl::ext::oneapi::experimental::work_group_size<1, 1, 0>;
-  // expected-error-re@sycl/ext/oneapi/kernel_properties/properties.hpp:* {{static assertion failed due to requirement {{.+}}: work_group_size property must only contain non-zero values.}}
-  // expected-error@sycl/ext/oneapi/kernel_properties/properties.hpp:* {{constexpr variable 'work_group_size<0, 1, 1>' must be initialized by a constant expression}}
+  // expected-error-re@sycl/ext/oneapi/kernel_properties/function_launch_properties.hpp:* {{static assertion failed due to requirement {{.+}}: work_group_size property must only contain non-zero values.}}
+  // expected-error@sycl/ext/oneapi/kernel_properties/function_launch_properties.hpp:* {{constexpr variable 'work_group_size<0, 1, 1>' must be initialized by a constant expression}}
   // expected-note@+1 {{in instantiation of variable template specialization 'sycl::ext::oneapi::experimental::work_group_size<0, 1, 1>' requested here}}
   auto WGSize10 = sycl::ext::oneapi::experimental::work_group_size<0, 1, 1>;
-  // expected-error-re@sycl/ext/oneapi/kernel_properties/properties.hpp:* {{static assertion failed due to requirement {{.+}}: work_group_size property must only contain non-zero values.}}
-  // expected-error@sycl/ext/oneapi/kernel_properties/properties.hpp:* {{constexpr variable 'work_group_size<1, 0, 1>' must be initialized by a constant expression}}
+  // expected-error-re@sycl/ext/oneapi/kernel_properties/function_launch_properties.hpp:* {{static assertion failed due to requirement {{.+}}: work_group_size property must only contain non-zero values.}}
+  // expected-error@sycl/ext/oneapi/kernel_properties/function_launch_properties.hpp:* {{constexpr variable 'work_group_size<1, 0, 1>' must be initialized by a constant expression}}
   // expected-note@+1 {{in instantiation of variable template specialization 'sycl::ext::oneapi::experimental::work_group_size<1, 0, 1>' requested here}}
   auto WGSize11 = sycl::ext::oneapi::experimental::work_group_size<1, 0, 1>;
 
-  // expected-error-re@sycl/ext/oneapi/kernel_properties/properties.hpp:* {{static assertion failed due to requirement {{.+}}: work_group_size property currently only supports up to three values.}}
-  // expected-error@sycl/ext/oneapi/kernel_properties/properties.hpp:* {{constexpr variable 'work_group_size<1, 1, 1, 1>' must be initialized by a constant expression}}
+  // expected-error-re@sycl/ext/oneapi/kernel_properties/function_launch_properties.hpp:* {{static assertion failed due to requirement {{.+}}: work_group_size property currently only supports up to three values.}}
+  // expected-error@sycl/ext/oneapi/kernel_properties/function_launch_properties.hpp:* {{constexpr variable 'work_group_size<1, 1, 1, 1>' must be initialized by a constant expression}}
   // expected-note@+1 {{in instantiation of variable template specialization 'sycl::ext::oneapi::experimental::work_group_size<1, 1, 1, 1>' requested here}}
   auto WGSize12 = sycl::ext::oneapi::experimental::work_group_size<1, 1, 1, 1>;
 
@@ -164,55 +164,55 @@ void check_work_group_size_hint() {
   // expected-error@+1 {{too few template arguments for variable template 'work_group_size_hint'}}
   auto WGSize0 = sycl::ext::oneapi::experimental::work_group_size_hint<>;
 
-  // expected-error-re@sycl/ext/oneapi/kernel_properties/properties.hpp:* {{static assertion failed due to requirement {{.+}}: work_group_size_hint property must only contain non-zero values.}}
-  // expected-error@sycl/ext/oneapi/kernel_properties/properties.hpp:* {{constexpr variable 'work_group_size_hint<0>' must be initialized by a constant expression}}
+  // expected-error-re@sycl/ext/oneapi/kernel_properties/function_launch_properties.hpp:* {{static assertion failed due to requirement {{.+}}: work_group_size_hint property must only contain non-zero values.}}
+  // expected-error@sycl/ext/oneapi/kernel_properties/function_launch_properties.hpp:* {{constexpr variable 'work_group_size_hint<0>' must be initialized by a constant expression}}
   // expected-note@+1 {{in instantiation of variable template specialization 'sycl::ext::oneapi::experimental::work_group_size_hint<0>' requested here}}
   auto WGSize1 = sycl::ext::oneapi::experimental::work_group_size_hint<0>;
-  // expected-error-re@sycl/ext/oneapi/kernel_properties/properties.hpp:* {{static assertion failed due to requirement {{.+}}: work_group_size_hint property must only contain non-zero values.}}
-  // expected-error@sycl/ext/oneapi/kernel_properties/properties.hpp:* {{constexpr variable 'work_group_size_hint<0, 0>' must be initialized by a constant expression}}
+  // expected-error-re@sycl/ext/oneapi/kernel_properties/function_launch_properties.hpp:* {{static assertion failed due to requirement {{.+}}: work_group_size_hint property must only contain non-zero values.}}
+  // expected-error@sycl/ext/oneapi/kernel_properties/function_launch_properties.hpp:* {{constexpr variable 'work_group_size_hint<0, 0>' must be initialized by a constant expression}}
   // expected-note@+1 {{in instantiation of variable template specialization 'sycl::ext::oneapi::experimental::work_group_size_hint<0, 0>' requested here}}
   auto WGSize2 = sycl::ext::oneapi::experimental::work_group_size_hint<0, 0>;
-  // expected-error-re@sycl/ext/oneapi/kernel_properties/properties.hpp:* {{static assertion failed due to requirement {{.+}}: work_group_size_hint property must only contain non-zero values.}}
-  // expected-error@sycl/ext/oneapi/kernel_properties/properties.hpp:* {{constexpr variable 'work_group_size_hint<1, 0>' must be initialized by a constant expression}}
+  // expected-error-re@sycl/ext/oneapi/kernel_properties/function_launch_properties.hpp:* {{static assertion failed due to requirement {{.+}}: work_group_size_hint property must only contain non-zero values.}}
+  // expected-error@sycl/ext/oneapi/kernel_properties/function_launch_properties.hpp:* {{constexpr variable 'work_group_size_hint<1, 0>' must be initialized by a constant expression}}
   // expected-note@+1 {{in instantiation of variable template specialization 'sycl::ext::oneapi::experimental::work_group_size_hint<1, 0>' requested here}}
   auto WGSize3 = sycl::ext::oneapi::experimental::work_group_size_hint<1, 0>;
-  // expected-error-re@sycl/ext/oneapi/kernel_properties/properties.hpp:* {{static assertion failed due to requirement {{.+}}: work_group_size_hint property must only contain non-zero values.}}
-  // expected-error@sycl/ext/oneapi/kernel_properties/properties.hpp:* {{constexpr variable 'work_group_size_hint<0, 1>' must be initialized by a constant expression}}
+  // expected-error-re@sycl/ext/oneapi/kernel_properties/function_launch_properties.hpp:* {{static assertion failed due to requirement {{.+}}: work_group_size_hint property must only contain non-zero values.}}
+  // expected-error@sycl/ext/oneapi/kernel_properties/function_launch_properties.hpp:* {{constexpr variable 'work_group_size_hint<0, 1>' must be initialized by a constant expression}}
   // expected-note@+1 {{in instantiation of variable template specialization 'sycl::ext::oneapi::experimental::work_group_size_hint<0, 1>' requested here}}
   auto WGSize4 = sycl::ext::oneapi::experimental::work_group_size_hint<0, 1>;
-  // expected-error-re@sycl/ext/oneapi/kernel_properties/properties.hpp:* {{static assertion failed due to requirement {{.+}}: work_group_size_hint property must only contain non-zero values.}}
-  // expected-error@sycl/ext/oneapi/kernel_properties/properties.hpp:* {{constexpr variable 'work_group_size_hint<0, 0, 0>' must be initialized by a constant expression}}
+  // expected-error-re@sycl/ext/oneapi/kernel_properties/function_launch_properties.hpp:* {{static assertion failed due to requirement {{.+}}: work_group_size_hint property must only contain non-zero values.}}
+  // expected-error@sycl/ext/oneapi/kernel_properties/function_launch_properties.hpp:* {{constexpr variable 'work_group_size_hint<0, 0, 0>' must be initialized by a constant expression}}
   // expected-note@+1 {{in instantiation of variable template specialization 'sycl::ext::oneapi::experimental::work_group_size_hint<0, 0, 0>' requested here}}
   auto WGSize5 = sycl::ext::oneapi::experimental::work_group_size_hint<0, 0, 0>;
-  // expected-error-re@sycl/ext/oneapi/kernel_properties/properties.hpp:* {{static assertion failed due to requirement {{.+}}: work_group_size_hint property must only contain non-zero values.}}
-  // expected-error@sycl/ext/oneapi/kernel_properties/properties.hpp:* {{constexpr variable 'work_group_size_hint<1, 0, 0>' must be initialized by a constant expression}}
+  // expected-error-re@sycl/ext/oneapi/kernel_properties/function_launch_properties.hpp:* {{static assertion failed due to requirement {{.+}}: work_group_size_hint property must only contain non-zero values.}}
+  // expected-error@sycl/ext/oneapi/kernel_properties/function_launch_properties.hpp:* {{constexpr variable 'work_group_size_hint<1, 0, 0>' must be initialized by a constant expression}}
   // expected-note@+1 {{in instantiation of variable template specialization 'sycl::ext::oneapi::experimental::work_group_size_hint<1, 0, 0>' requested here}}
   auto WGSize6 = sycl::ext::oneapi::experimental::work_group_size_hint<1, 0, 0>;
-  // expected-error-re@sycl/ext/oneapi/kernel_properties/properties.hpp:* {{static assertion failed due to requirement {{.+}}: work_group_size_hint property must only contain non-zero values.}}
-  // expected-error@sycl/ext/oneapi/kernel_properties/properties.hpp:* {{constexpr variable 'work_group_size_hint<0, 1, 0>' must be initialized by a constant expression}}
+  // expected-error-re@sycl/ext/oneapi/kernel_properties/function_launch_properties.hpp:* {{static assertion failed due to requirement {{.+}}: work_group_size_hint property must only contain non-zero values.}}
+  // expected-error@sycl/ext/oneapi/kernel_properties/function_launch_properties.hpp:* {{constexpr variable 'work_group_size_hint<0, 1, 0>' must be initialized by a constant expression}}
   // expected-note@+1 {{in instantiation of variable template specialization 'sycl::ext::oneapi::experimental::work_group_size_hint<0, 1, 0>' requested here}}
   auto WGSize7 = sycl::ext::oneapi::experimental::work_group_size_hint<0, 1, 0>;
-  // expected-error-re@sycl/ext/oneapi/kernel_properties/properties.hpp:* {{static assertion failed due to requirement {{.+}}: work_group_size_hint property must only contain non-zero values.}}
-  // expected-error@sycl/ext/oneapi/kernel_properties/properties.hpp:* {{constexpr variable 'work_group_size_hint<0, 0, 1>' must be initialized by a constant expression}}
+  // expected-error-re@sycl/ext/oneapi/kernel_properties/function_launch_properties.hpp:* {{static assertion failed due to requirement {{.+}}: work_group_size_hint property must only contain non-zero values.}}
+  // expected-error@sycl/ext/oneapi/kernel_properties/function_launch_properties.hpp:* {{constexpr variable 'work_group_size_hint<0, 0, 1>' must be initialized by a constant expression}}
   // expected-note@+1 {{in instantiation of variable template specialization 'sycl::ext::oneapi::experimental::work_group_size_hint<0, 0, 1>' requested here}}
   auto WGSize8 = sycl::ext::oneapi::experimental::work_group_size_hint<0, 0, 1>;
-  // expected-error-re@sycl/ext/oneapi/kernel_properties/properties.hpp:* {{static assertion failed due to requirement {{.+}}: work_group_size_hint property must only contain non-zero values.}}
-  // expected-error@sycl/ext/oneapi/kernel_properties/properties.hpp:* {{constexpr variable 'work_group_size_hint<1, 1, 0>' must be initialized by a constant expression}}
+  // expected-error-re@sycl/ext/oneapi/kernel_properties/function_launch_properties.hpp:* {{static assertion failed due to requirement {{.+}}: work_group_size_hint property must only contain non-zero values.}}
+  // expected-error@sycl/ext/oneapi/kernel_properties/function_launch_properties.hpp:* {{constexpr variable 'work_group_size_hint<1, 1, 0>' must be initialized by a constant expression}}
   // expected-note@+1 {{in instantiation of variable template specialization 'sycl::ext::oneapi::experimental::work_group_size_hint<1, 1, 0>' requested here}}
   auto WGSize9 = sycl::ext::oneapi::experimental::work_group_size_hint<1, 1, 0>;
-  // expected-error-re@sycl/ext/oneapi/kernel_properties/properties.hpp:* {{static assertion failed due to requirement {{.+}}: work_group_size_hint property must only contain non-zero values.}}
-  // expected-error@sycl/ext/oneapi/kernel_properties/properties.hpp:* {{constexpr variable 'work_group_size_hint<0, 1, 1>' must be initialized by a constant expression}}
+  // expected-error-re@sycl/ext/oneapi/kernel_properties/function_launch_properties.hpp:* {{static assertion failed due to requirement {{.+}}: work_group_size_hint property must only contain non-zero values.}}
+  // expected-error@sycl/ext/oneapi/kernel_properties/function_launch_properties.hpp:* {{constexpr variable 'work_group_size_hint<0, 1, 1>' must be initialized by a constant expression}}
   // expected-note@+2 {{in instantiation of variable template specialization 'sycl::ext::oneapi::experimental::work_group_size_hint<0, 1, 1>' requested here}}
   auto WGSize10 =
       sycl::ext::oneapi::experimental::work_group_size_hint<0, 1, 1>;
-  // expected-error-re@sycl/ext/oneapi/kernel_properties/properties.hpp:* {{static assertion failed due to requirement {{.+}}: work_group_size_hint property must only contain non-zero values.}}
-  // expected-error@sycl/ext/oneapi/kernel_properties/properties.hpp:* {{constexpr variable 'work_group_size_hint<1, 0, 1>' must be initialized by a constant expression}}
+  // expected-error-re@sycl/ext/oneapi/kernel_properties/function_launch_properties.hpp:* {{static assertion failed due to requirement {{.+}}: work_group_size_hint property must only contain non-zero values.}}
+  // expected-error@sycl/ext/oneapi/kernel_properties/function_launch_properties.hpp:* {{constexpr variable 'work_group_size_hint<1, 0, 1>' must be initialized by a constant expression}}
   // expected-note@+2 {{in instantiation of variable template specialization 'sycl::ext::oneapi::experimental::work_group_size_hint<1, 0, 1>' requested here}}
   auto WGSize11 =
       sycl::ext::oneapi::experimental::work_group_size_hint<1, 0, 1>;
 
-  // expected-error-re@sycl/ext/oneapi/kernel_properties/properties.hpp:* {{static assertion failed due to requirement {{.+}}: work_group_size_hint property currently only supports up to three values.}}
-  // expected-error@sycl/ext/oneapi/kernel_properties/properties.hpp:* {{constexpr variable 'work_group_size_hint<1, 1, 1, 1>' must be initialized by a constant expression}}
+  // expected-error-re@sycl/ext/oneapi/kernel_properties/function_launch_properties.hpp:* {{static assertion failed due to requirement {{.+}}: work_group_size_hint property currently only supports up to three values.}}
+  // expected-error@sycl/ext/oneapi/kernel_properties/function_launch_properties.hpp:* {{constexpr variable 'work_group_size_hint<1, 1, 1, 1>' must be initialized by a constant expression}}
   // expected-note@+2 {{in instantiation of variable template specialization 'sycl::ext::oneapi::experimental::work_group_size_hint<1, 1, 1, 1>' requested here}}
   auto WGSize12 =
       sycl::ext::oneapi::experimental::work_group_size_hint<1, 1, 1, 1>;
@@ -301,8 +301,8 @@ void check_sub_group_size() {
   // expected-error@+1 {{too few template arguments for variable template 'sub_group_size'}}
   auto WGSize0 = sycl::ext::oneapi::experimental::sub_group_size<>;
 
-  // expected-error-re@sycl/ext/oneapi/kernel_properties/properties.hpp:* {{static assertion failed due to requirement {{.+}}: sub_group_size_key property must contain a non-zero value.}}
-  // expected-error@sycl/ext/oneapi/kernel_properties/properties.hpp:* {{constexpr variable 'sub_group_size<0>' must be initialized by a constant expression}}
+  // expected-error-re@sycl/ext/oneapi/kernel_properties/function_launch_properties.hpp:* {{static assertion failed due to requirement {{.+}}: sub_group_size property must contain a non-zero value.}}
+  // expected-error@sycl/ext/oneapi/kernel_properties/function_launch_properties.hpp:* {{constexpr variable 'sub_group_size<0>' must be initialized by a constant expression}}
   // expected-note@+1 {{in instantiation of variable template specialization 'sycl::ext::oneapi::experimental::sub_group_size<0>' requested here}}
   auto WGSize1 = sycl::ext::oneapi::experimental::sub_group_size<0>;
 
diff --git a/sycl/test/include_deps/sycl_detail_core.hpp.cpp b/sycl/test/include_deps/sycl_detail_core.hpp.cpp
index 2b8ac26da9ddc..1aa2adc6b740b 100644
--- a/sycl/test/include_deps/sycl_detail_core.hpp.cpp
+++ b/sycl/test/include_deps/sycl_detail_core.hpp.cpp
@@ -113,10 +113,12 @@
 // CHECK-NEXT: device_selector.hpp
 // CHECK-NEXT: kernel_bundle_enums.hpp
 // CHECK-NEXT: ext/oneapi/kernel_properties/properties.hpp
+// CHECK-NEXT: ext/oneapi/kernel_properties/function_launch_properties.hpp
+// CHECK-NEXT: ext/oneapi/kernel_properties/function_properties.hpp
+// CHECK-NEXT: ext/oneapi/properties/property_value.hpp
+// CHECK-NEXT: ext/oneapi/properties/property.hpp
 // CHECK-NEXT: ext/oneapi/properties/properties.hpp
 // CHECK-NEXT: ext/oneapi/properties/property_utils.hpp
-// CHECK-NEXT: ext/oneapi/properties/property.hpp
-// CHECK-NEXT: ext/oneapi/properties/property_value.hpp
 // CHECK-NEXT: event.hpp
 // CHECK-NEXT: exception_list.hpp
 // CHECK-NEXT: ext/oneapi/device_global/device_global.hpp
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 a4c53ca4f9439..7194a1acf4c80 100644
--- a/sycl/test/include_deps/sycl_khr_includes_handler.hpp.cpp
+++ b/sycl/test/include_deps/sycl_khr_includes_handler.hpp.cpp
@@ -135,7 +135,9 @@
 // CHECK-NEXT: ext/oneapi/experimental/work_group_memory.hpp
 // CHECK-NEXT: ext/oneapi/experimental/use_root_sync_prop.hpp
 // CHECK-NEXT: ext/oneapi/experimental/virtual_functions.hpp
+// CHECK-NEXT: ext/oneapi/kernel_properties/function_properties.hpp
 // CHECK-NEXT: ext/oneapi/kernel_properties/properties.hpp
+// CHECK-NEXT: ext/oneapi/kernel_properties/function_launch_properties.hpp
 // CHECK-NEXT: ext/oneapi/work_group_scratch_memory.hpp
 // CHECK-NEXT: detail/sycl_local_mem_builtins.hpp
 // CHECK-NEXT: detail/nd_range_view.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 b82f38f1cfdd6..edabb605d9ff3 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
@@ -143,7 +143,9 @@
 // CHECK-NEXT: ext/oneapi/experimental/work_group_memory.hpp
 // CHECK-NEXT: ext/oneapi/experimental/use_root_sync_prop.hpp
 // CHECK-NEXT: ext/oneapi/experimental/virtual_functions.hpp
+// CHECK-NEXT: ext/oneapi/kernel_properties/function_properties.hpp
 // CHECK-NEXT: ext/oneapi/kernel_properties/properties.hpp
+// CHECK-NEXT: ext/oneapi/kernel_properties/function_launch_properties.hpp
 // CHECK-NEXT: ext/oneapi/work_group_scratch_memory.hpp
 // CHECK-NEXT: detail/sycl_local_mem_builtins.hpp
 // CHECK-NEXT: detail/nd_range_view.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 8ddf2a9576ed0..ea7d66f1d650c 100644
--- a/sycl/test/include_deps/sycl_khr_includes_queue.hpp.cpp
+++ b/sycl/test/include_deps/sycl_khr_includes_queue.hpp.cpp
@@ -117,10 +117,12 @@
 // CHECK-NEXT: device_selector.hpp
 // CHECK-NEXT: kernel_bundle_enums.hpp
 // CHECK-NEXT: ext/oneapi/kernel_properties/properties.hpp
+// CHECK-NEXT: ext/oneapi/kernel_properties/function_launch_properties.hpp
+// CHECK-NEXT: ext/oneapi/kernel_properties/function_properties.hpp
+// CHECK-NEXT: ext/oneapi/properties/property_value.hpp
+// CHECK-NEXT: ext/oneapi/properties/property.hpp
 // CHECK-NEXT: ext/oneapi/properties/properties.hpp
 // CHECK-NEXT: ext/oneapi/properties/property_utils.hpp
-// CHECK-NEXT: ext/oneapi/properties/property.hpp
-// CHECK-NEXT: ext/oneapi/properties/property_value.hpp
 // CHECK-NEXT: event.hpp
 // CHECK-NEXT: exception_list.hpp
 // CHECK-NEXT: ext/oneapi/device_global/device_global.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 6775a70dbd859..90bd4c21c51f6 100644
--- a/sycl/test/include_deps/sycl_khr_includes_reduction.hpp.cpp
+++ b/sycl/test/include_deps/sycl_khr_includes_reduction.hpp.cpp
@@ -172,7 +172,9 @@
 // CHECK-NEXT: ext/oneapi/experimental/work_group_memory.hpp
 // CHECK-NEXT: ext/oneapi/experimental/use_root_sync_prop.hpp
 // CHECK-NEXT: ext/oneapi/experimental/virtual_functions.hpp
+// CHECK-NEXT: ext/oneapi/kernel_properties/function_properties.hpp
 // CHECK-NEXT: ext/oneapi/kernel_properties/properties.hpp
+// CHECK-NEXT: ext/oneapi/kernel_properties/function_launch_properties.hpp
 // CHECK-NEXT: ext/oneapi/work_group_scratch_memory.hpp
 // CHECK-NEXT: detail/sycl_local_mem_builtins.hpp
 // CHECK-NEXT: detail/nd_range_view.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 8b69fc29fe202..abfcf488bf61e 100644
--- a/sycl/test/include_deps/sycl_khr_includes_stream.hpp.cpp
+++ b/sycl/test/include_deps/sycl_khr_includes_stream.hpp.cpp
@@ -153,7 +153,9 @@
 // CHECK-NEXT: ext/oneapi/experimental/work_group_memory.hpp
 // CHECK-NEXT: ext/oneapi/experimental/use_root_sync_prop.hpp
 // CHECK-NEXT: ext/oneapi/experimental/virtual_functions.hpp
+// CHECK-NEXT: ext/oneapi/kernel_properties/function_properties.hpp
 // CHECK-NEXT: ext/oneapi/kernel_properties/properties.hpp
+// CHECK-NEXT: ext/oneapi/kernel_properties/function_launch_properties.hpp
 // CHECK-NEXT: ext/oneapi/work_group_scratch_memory.hpp
 // CHECK-NEXT: detail/sycl_local_mem_builtins.hpp
 // CHECK-NEXT: detail/nd_range_view.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 10d253de26117..a646ff9e4bd3a 100644
--- a/sycl/test/include_deps/sycl_khr_includes_usm.hpp.cpp
+++ b/sycl/test/include_deps/sycl_khr_includes_usm.hpp.cpp
@@ -132,10 +132,12 @@
 // CHECK-NEXT: detail/optional.hpp
 // CHECK-NEXT: detail/range_rounding.hpp
 // CHECK-NEXT: ext/oneapi/kernel_properties/properties.hpp
+// CHECK-NEXT: ext/oneapi/kernel_properties/function_launch_properties.hpp
+// CHECK-NEXT: ext/oneapi/kernel_properties/function_properties.hpp
+// CHECK-NEXT: ext/oneapi/properties/property_value.hpp
+// CHECK-NEXT: ext/oneapi/properties/property.hpp
 // CHECK-NEXT: ext/oneapi/properties/properties.hpp
 // CHECK-NEXT: ext/oneapi/properties/property_utils.hpp
-// CHECK-NEXT: ext/oneapi/properties/property.hpp
-// CHECK-NEXT: ext/oneapi/properties/property_value.hpp
 // CHECK-NEXT: event.hpp
 // CHECK-NEXT: exception_list.hpp
 // CHECK-NEXT: ext/oneapi/device_global/device_global.hpp

From d7405eb5c21f16f8c0dac7e094be319ff296ec98 Mon Sep 17 00:00:00 2001
From: y <konstantinos.parasyris@intel.com>
Date: Tue, 14 Apr 2026 10:21:49 -0700
Subject: [PATCH 02/11] Fold lightweight free-function properties into
 function_properties.hpp

---
 ..._ext_oneapi_free_function_kernels.asciidoc |  39 +--
 ...sycl_ext_oneapi_kernel_properties.asciidoc |  23 +-
 .../function_launch_properties.hpp            | 329 ------------------
 .../kernel_properties/function_properties.hpp | 315 ++++++++++++++++-
 .../oneapi/kernel_properties/properties.hpp   |   2 +-
 .../properties/function_properties_split.cpp  |  37 ++
 .../properties/properties_kernel_negative.cpp | 100 +++---
 .../include_deps/sycl_detail_core.hpp.cpp     |   1 -
 .../sycl_khr_includes_handler.hpp.cpp         |   1 -
 .../sycl_khr_includes_kernel_bundle.hpp.cpp   |   1 -
 .../sycl_khr_includes_queue.hpp.cpp           |   1 -
 .../sycl_khr_includes_reduction.hpp.cpp       |   1 -
 .../sycl_khr_includes_stream.hpp.cpp          |   1 -
 .../sycl_khr_includes_usm.hpp.cpp             |   1 -
 14 files changed, 424 insertions(+), 428 deletions(-)
 delete mode 100644 sycl/include/sycl/ext/oneapi/kernel_properties/function_launch_properties.hpp
 create mode 100644 sycl/test/extensions/properties/function_properties_split.cpp

diff --git a/sycl/doc/extensions/experimental/sycl_ext_oneapi_free_function_kernels.asciidoc b/sycl/doc/extensions/experimental/sycl_ext_oneapi_free_function_kernels.asciidoc
index 3359b3e0be1b4..d33b59a859229 100644
--- a/sycl/doc/extensions/experimental/sycl_ext_oneapi_free_function_kernels.asciidoc
+++ b/sycl/doc/extensions/experimental/sycl_ext_oneapi_free_function_kernels.asciidoc
@@ -119,28 +119,23 @@ choice of headers depending on which properties they need:
 
 * `#include <sycl/ext/oneapi/kernel_properties/function_properties.hpp>` is
   sufficient for `SYCL_EXT_ONEAPI_FUNCTION_PROPERTY`,
-  `nd_range_kernel<Dims>`, and `single_task_kernel`.
-
-* `#include <sycl/ext/oneapi/kernel_properties/function_launch_properties.hpp>`
-  additionally provides the launch-configuration properties that may be applied
-  directly to a free function kernel declaration, such as
-  `work_group_size`, `work_group_size_hint`, `sub_group_size`,
-  `max_work_group_size`, and `max_linear_work_group_size`.
+  `nd_range_kernel<Dims>`, `single_task_kernel`, and the standalone
+  compile-time kernel properties that may be applied directly to a free
+  function kernel declaration, such as `work_group_size`,
+  `work_group_size_hint`, `sub_group_size`, `max_work_group_size`, and
+  `max_linear_work_group_size`.
 
 * `#include <sycl/ext/oneapi/kernel_properties/properties.hpp>` provides the
   full kernel properties interface, including property lists such as
   `properties{...}` and embedded kernel properties via `properties_tag`.
 
-Applications may include the umbrella header in all cases. The lighter-weight
-headers are intended for code that only needs function annotations on free
-function kernels and where reducing compile time is a priority.
+Applications may include the umbrella header in all cases. The lightweight
+header is intended for code that defines free-function kernels and only needs
+the free-function annotation path.
 
-The lighter-weight headers retain validation of each individual property, such
-as arity and non-zero size requirements, but they do not provide the
-cross-property validation that is performed when properties are combined via
-the full property-list machinery. For example, checks for conflicting
-combinations such as `work_group_size` together with `max_work_group_size` are
-available only through the umbrella header.
+Code that forms property lists such as `properties{...}`, uses
+`properties_tag`, or depends on the umbrella property's property-list conflict
+checks should include `kernel_properties/properties.hpp`.
 
 === Defining a free function kernel
 
@@ -833,12 +828,12 @@ in link:../experimental/sycl_ext_oneapi_kernel_properties.asciidoc[
 sycl_ext_oneapi_kernel_properties] by applying the properties to the function
 declaration as illustrated below.
 
-In the {dpcpp} implementation, code that uses only function annotations may
-include either `function_properties.hpp` or
-`function_launch_properties.hpp` instead of the full
-`kernel_properties/properties.hpp` header. Applications that need property-list
-semantics, including cross-property validation, should include the umbrella
-header.
+In the {dpcpp} implementation, code that defines free-function kernels may
+include `function_properties.hpp` instead of the full
+`kernel_properties/properties.hpp` header when it only needs the
+free-function annotation path. Applications that use property-list semantics,
+including `properties{...}`, `properties_tag`, or the associated
+property-list conflict checks, should include the umbrella header.
 
 ```
 SYCL_EXT_ONEAPI_FUNCTION_PROPERTY((syclexp::nd_range_kernel<1>))
diff --git a/sycl/doc/extensions/experimental/sycl_ext_oneapi_kernel_properties.asciidoc b/sycl/doc/extensions/experimental/sycl_ext_oneapi_kernel_properties.asciidoc
index a36020e31bba4..52fc1ea1d07a6 100644
--- a/sycl/doc/extensions/experimental/sycl_ext_oneapi_kernel_properties.asciidoc
+++ b/sycl/doc/extensions/experimental/sycl_ext_oneapi_kernel_properties.asciidoc
@@ -130,24 +130,19 @@ The implementation also provides lighter-weight headers for code that only
 needs free-function annotations:
 
 * `#include <sycl/ext/oneapi/kernel_properties/function_properties.hpp>` for
-  `nd_range_kernel<Dims>`, `single_task_kernel`, and
-  `SYCL_EXT_ONEAPI_FUNCTION_PROPERTY`.
-
-* `#include <sycl/ext/oneapi/kernel_properties/function_launch_properties.hpp>`
-  for the launch-configuration properties that can be applied directly to free
-  function declarations, including `work_group_size`,
-  `work_group_size_hint`, `sub_group_size`, `max_work_group_size`, and
-  `max_linear_work_group_size`.
+  `nd_range_kernel<Dims>`, `single_task_kernel`,
+  `SYCL_EXT_ONEAPI_FUNCTION_PROPERTY`, and the standalone compile-time kernel
+  properties that may be applied directly to a free function declaration, such
+  as `work_group_size`, `work_group_size_hint`, `sub_group_size`,
+  `max_work_group_size`, and `max_linear_work_group_size`.
 
 These lighter-weight headers are primarily intended for code paths where
 reduced compile time is a high priority and the application only needs
 function-level annotations.
-
-They retain validation of each individual property, but they do not provide
-the cross-property validation that depends on forming a full property list.
-For example, checks for conflicting combinations such as `work_group_size`
-together with `max_work_group_size` or `max_linear_work_group_size` are
-performed only when using the umbrella header.
+The `function_properties.hpp` header is intended for the free-function kernel
+definition path. Code that forms property lists, uses `properties_tag`, or
+depends on the umbrella property's property-list conflict checks should include
+`kernel_properties/properties.hpp`.
 
 === Kernel Properties
 
diff --git a/sycl/include/sycl/ext/oneapi/kernel_properties/function_launch_properties.hpp b/sycl/include/sycl/ext/oneapi/kernel_properties/function_launch_properties.hpp
deleted file mode 100644
index 94fe9124145f0..0000000000000
--- a/sycl/include/sycl/ext/oneapi/kernel_properties/function_launch_properties.hpp
+++ /dev/null
@@ -1,329 +0,0 @@
-//==--- function_launch_properties.hpp - SYCL function launch properties --==//
-//
-// 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
-
-// This header extends the split kernel-property path with launch-tuning
-// annotations. Keep these public property_value definitions local to this split
-// header so the umbrella include reuses the same types and preserves
-// decltype(...) identity without pulling the full kernel-properties machinery
-// into standalone launch-property use.
-
-#include <array>
-#include <stddef.h>
-#include <stdint.h>
-
-#include <sycl/ext/oneapi/kernel_properties/function_properties.hpp>
-#include <sycl/ext/oneapi/properties/property_value.hpp>
-
-namespace sycl {
-inline namespace _V1 {
-namespace ext::oneapi::experimental {
-namespace detail {
-
-template <typename PropKey, typename Properties> struct ConflictingProperties;
-
-template <size_t... Xs> struct LaunchAllNonZero {
-  static constexpr bool value = true;
-};
-template <size_t X, size_t... Xs> struct LaunchAllNonZero<X, Xs...> {
-  static constexpr bool value = X > 0 && LaunchAllNonZero<Xs...>::value;
-};
-
-inline constexpr size_t LaunchDecimalBase = 10;
-
-template <size_t... Sizes> struct LaunchSizeList {};
-template <char... Chars> struct LaunchCharList {};
-
-template <char... Chars> struct LaunchCharsToStr {
-  static constexpr const char value[] = {Chars..., '\0'};
-};
-
-template <typename List, typename ParsedList, char... Chars>
-struct LaunchSizeListToStrHelper;
-
-template <size_t Value, size_t... Values, char... ParsedChars, char... Chars>
-struct LaunchSizeListToStrHelper<LaunchSizeList<Value, Values...>,
-                                 LaunchCharList<ParsedChars...>, Chars...>
-    : LaunchSizeListToStrHelper<
-          LaunchSizeList<Value / LaunchDecimalBase, Values...>,
-          LaunchCharList<ParsedChars...>, '0' + (Value % LaunchDecimalBase),
-          Chars...> {};
-
-template <size_t... Values, char... ParsedChars, char... Chars>
-struct LaunchSizeListToStrHelper<LaunchSizeList<0, Values...>,
-                                 LaunchCharList<ParsedChars...>, Chars...>
-    : LaunchSizeListToStrHelper<LaunchSizeList<Values...>,
-                                LaunchCharList<ParsedChars..., Chars..., ','>> {
-};
-
-template <size_t... Values, char... ParsedChars>
-struct LaunchSizeListToStrHelper<LaunchSizeList<0, Values...>,
-                                 LaunchCharList<ParsedChars...>>
-    : LaunchSizeListToStrHelper<LaunchSizeList<Values...>,
-                                LaunchCharList<ParsedChars..., '0', ','>> {};
-
-template <char... ParsedChars, char... Chars>
-struct LaunchSizeListToStrHelper<LaunchSizeList<0>,
-                                 LaunchCharList<ParsedChars...>, Chars...>
-    : LaunchCharsToStr<ParsedChars..., Chars...> {};
-
-template <char... ParsedChars>
-struct LaunchSizeListToStrHelper<LaunchSizeList<0>,
-                                 LaunchCharList<ParsedChars...>>
-    : LaunchCharsToStr<ParsedChars..., '0'> {};
-
-template <>
-struct LaunchSizeListToStrHelper<LaunchSizeList<>, LaunchCharList<>>
-    : LaunchCharsToStr<> {};
-
-template <size_t... Sizes>
-struct LaunchSizeListToStr
-    : LaunchSizeListToStrHelper<LaunchSizeList<Sizes...>, LaunchCharList<>> {};
-
-} // namespace detail
-
-struct work_group_size_key
-    : detail::compile_time_property_key<detail::PropKind::WorkGroupSize> {
-  template <size_t... Dims>
-  using value_t = property_value<work_group_size_key,
-                                 std::integral_constant<size_t, Dims>...>;
-};
-
-struct work_group_size_hint_key
-    : detail::compile_time_property_key<detail::PropKind::WorkGroupSizeHint> {
-  template <size_t... Dims>
-  using value_t = property_value<work_group_size_hint_key,
-                                 std::integral_constant<size_t, Dims>...>;
-};
-
-struct sub_group_size_key
-    : detail::compile_time_property_key<detail::PropKind::SubGroupSize> {
-  template <uint32_t Size>
-  using value_t = property_value<sub_group_size_key,
-                                 std::integral_constant<uint32_t, Size>>;
-};
-
-struct max_work_group_size_key
-    : detail::compile_time_property_key<detail::PropKind::MaxWorkGroupSize> {
-  template <size_t... Dims>
-  using value_t = property_value<max_work_group_size_key,
-                                 std::integral_constant<size_t, Dims>...>;
-};
-
-struct max_linear_work_group_size_key
-    : detail::compile_time_property_key<
-          detail::PropKind::MaxLinearWorkGroupSize> {
-  template <size_t Size>
-  using value_t = property_value<max_linear_work_group_size_key,
-                                 std::integral_constant<size_t, Size>>;
-};
-
-template <size_t Dim0, size_t... Dims>
-struct property_value<work_group_size_key, std::integral_constant<size_t, Dim0>,
-                      std::integral_constant<size_t, Dims>...>
-    : detail::property_base<
-          property_value<work_group_size_key,
-                         std::integral_constant<size_t, Dim0>,
-                         std::integral_constant<size_t, Dims>...>,
-          detail::PropKind::WorkGroupSize, work_group_size_key> {
-  static_assert(
-      sizeof...(Dims) + 1 <= 3,
-      "work_group_size property currently only supports up to three values.");
-  static_assert(detail::LaunchAllNonZero<Dim0, Dims...>::value,
-                "work_group_size property must only contain non-zero values.");
-
-  constexpr size_t operator[](int Dim) const {
-    return std::array<size_t, sizeof...(Dims) + 1>{Dim0, Dims...}[Dim];
-  }
-
-private:
-  constexpr size_t size() const { return sizeof...(Dims) + 1; }
-
-  template <typename, typename> friend struct detail::ConflictingProperties;
-};
-
-template <size_t Dim0, size_t... Dims>
-struct property_value<work_group_size_hint_key,
-                      std::integral_constant<size_t, Dim0>,
-                      std::integral_constant<size_t, Dims>...>
-    : detail::property_base<
-          property_value<work_group_size_hint_key,
-                         std::integral_constant<size_t, Dim0>,
-                         std::integral_constant<size_t, Dims>...>,
-          detail::PropKind::WorkGroupSizeHint, work_group_size_hint_key> {
-  static_assert(sizeof...(Dims) + 1 <= 3,
-                "work_group_size_hint property currently only supports up to "
-                "three values.");
-  static_assert(
-      detail::LaunchAllNonZero<Dim0, Dims...>::value,
-      "work_group_size_hint property must only contain non-zero values.");
-
-  constexpr size_t operator[](int Dim) const {
-    return std::array<size_t, sizeof...(Dims) + 1>{Dim0, Dims...}[Dim];
-  }
-};
-
-template <uint32_t Size>
-struct property_value<sub_group_size_key,
-                      std::integral_constant<uint32_t, Size>>
-    : detail::property_base<
-          property_value<sub_group_size_key,
-                         std::integral_constant<uint32_t, Size>>,
-          detail::PropKind::SubGroupSize, sub_group_size_key> {
-  static_assert(Size != 0,
-                "sub_group_size property must contain a non-zero value.");
-
-  using value_t = std::integral_constant<uint32_t, Size>;
-  static constexpr uint32_t value = Size;
-};
-
-template <size_t Dim0, size_t... Dims>
-struct property_value<max_work_group_size_key,
-                      std::integral_constant<size_t, Dim0>,
-                      std::integral_constant<size_t, Dims>...>
-    : detail::property_base<
-          property_value<max_work_group_size_key,
-                         std::integral_constant<size_t, Dim0>,
-                         std::integral_constant<size_t, Dims>...>,
-          detail::PropKind::MaxWorkGroupSize, max_work_group_size_key> {
-  static_assert(
-      sizeof...(Dims) + 1 <= 3,
-      "max_work_group_size currently only supports up to three values.");
-  static_assert(detail::LaunchAllNonZero<Dim0, Dims...>::value,
-                "max_work_group_size must only contain non-zero values.");
-
-  constexpr size_t operator[](int Dim) const {
-    return std::array<size_t, sizeof...(Dims) + 1>{Dim0, Dims...}[Dim];
-  }
-
-private:
-  constexpr size_t size() const { return sizeof...(Dims) + 1; }
-
-  template <typename, typename> friend struct detail::ConflictingProperties;
-};
-
-template <size_t Size>
-struct property_value<max_linear_work_group_size_key,
-                      std::integral_constant<size_t, Size>>
-    : detail::property_base<
-          property_value<max_linear_work_group_size_key,
-                         std::integral_constant<size_t, Size>>,
-          detail::PropKind::MaxLinearWorkGroupSize,
-          max_linear_work_group_size_key> {
-  static_assert(Size != 0,
-                "max_linear_work_group_size must contain a non-zero value.");
-
-  using value_t = std::integral_constant<size_t, Size>;
-  static constexpr size_t value = Size;
-};
-
-namespace detail {
-
-template <size_t... Dims>
-struct HasCompileTimeEffect<work_group_size_key::value_t<Dims...>>
-    : std::true_type {};
-template <size_t... Dims>
-struct HasCompileTimeEffect<work_group_size_hint_key::value_t<Dims...>>
-    : std::true_type {};
-template <uint32_t Size>
-struct HasCompileTimeEffect<sub_group_size_key::value_t<Size>>
-    : std::true_type {};
-template <size_t... Dims>
-struct HasCompileTimeEffect<max_work_group_size_key::value_t<Dims...>>
-    : std::true_type {};
-template <size_t Size>
-struct HasCompileTimeEffect<max_linear_work_group_size_key::value_t<Size>>
-    : std::true_type {};
-
-template <size_t Dim0, size_t... Dims>
-struct PropertyMetaInfo<work_group_size_key::value_t<Dim0, Dims...>> {
-  static constexpr const char *name = "sycl-work-group-size";
-  static constexpr const char *value =
-      LaunchSizeListToStr<Dim0, Dims...>::value;
-};
-template <size_t Dim0, size_t... Dims>
-struct FunctionPropertyMetaInfo<work_group_size_key::value_t<Dim0, Dims...>> {
-  static constexpr const char *name = "sycl-work-group-size";
-  static constexpr const char *value =
-      LaunchSizeListToStr<Dim0, Dims...>::value;
-};
-
-template <size_t Dim0, size_t... Dims>
-struct PropertyMetaInfo<work_group_size_hint_key::value_t<Dim0, Dims...>> {
-  static constexpr const char *name = "sycl-work-group-size-hint";
-  static constexpr const char *value =
-      LaunchSizeListToStr<Dim0, Dims...>::value;
-};
-template <size_t Dim0, size_t... Dims>
-struct FunctionPropertyMetaInfo<
-    work_group_size_hint_key::value_t<Dim0, Dims...>> {
-  static constexpr const char *name = "sycl-work-group-size-hint";
-  static constexpr const char *value =
-      LaunchSizeListToStr<Dim0, Dims...>::value;
-};
-
-template <uint32_t Size>
-struct PropertyMetaInfo<sub_group_size_key::value_t<Size>> {
-  static constexpr const char *name = "sycl-sub-group-size";
-  static constexpr uint32_t value = Size;
-};
-template <uint32_t Size>
-struct FunctionPropertyMetaInfo<sub_group_size_key::value_t<Size>> {
-  static constexpr const char *name = "sycl-sub-group-size";
-  static constexpr uint32_t value = Size;
-};
-
-template <size_t Dim0, size_t... Dims>
-struct PropertyMetaInfo<max_work_group_size_key::value_t<Dim0, Dims...>> {
-  static constexpr const char *name = "sycl-max-work-group-size";
-  static constexpr const char *value =
-      LaunchSizeListToStr<Dim0, Dims...>::value;
-};
-template <size_t Dim0, size_t... Dims>
-struct FunctionPropertyMetaInfo<
-    max_work_group_size_key::value_t<Dim0, Dims...>> {
-  static constexpr const char *name = "sycl-max-work-group-size";
-  static constexpr const char *value =
-      LaunchSizeListToStr<Dim0, Dims...>::value;
-};
-
-template <size_t Size>
-struct PropertyMetaInfo<max_linear_work_group_size_key::value_t<Size>> {
-  static constexpr const char *name = "sycl-max-linear-work-group-size";
-  static constexpr size_t value = Size;
-};
-template <size_t Size>
-struct FunctionPropertyMetaInfo<max_linear_work_group_size_key::value_t<Size>> {
-  static constexpr const char *name = "sycl-max-linear-work-group-size";
-  static constexpr size_t value = Size;
-};
-
-} // namespace detail
-
-template <size_t Dim0, size_t... Dims>
-inline constexpr work_group_size_key::value_t<Dim0, Dims...> work_group_size;
-
-template <size_t Dim0, size_t... Dims>
-inline constexpr work_group_size_hint_key::value_t<Dim0, Dims...>
-    work_group_size_hint;
-
-template <uint32_t Size>
-inline constexpr sub_group_size_key::value_t<Size> sub_group_size;
-
-template <size_t Dim0, size_t... Dims>
-inline constexpr max_work_group_size_key::value_t<Dim0, Dims...>
-    max_work_group_size;
-
-template <size_t Size>
-inline constexpr max_linear_work_group_size_key::value_t<Size>
-    max_linear_work_group_size;
-
-} // namespace ext::oneapi::experimental
-} // namespace _V1
-} // namespace sycl
\ No newline at end of file
diff --git a/sycl/include/sycl/ext/oneapi/kernel_properties/function_properties.hpp b/sycl/include/sycl/ext/oneapi/kernel_properties/function_properties.hpp
index 1b8a133e05b9d..dda6371583db6 100644
--- a/sycl/include/sycl/ext/oneapi/kernel_properties/function_properties.hpp
+++ b/sycl/include/sycl/ext/oneapi/kernel_properties/function_properties.hpp
@@ -9,11 +9,14 @@
 #pragma once
 
 // This header is the lightweight split entry point for free-function kernel
-// annotations. Keep the public property_value definitions here, rather than
-// only in kernel_properties/properties.hpp, so standalone users and umbrella
-// users observe the same decltype(...) while avoiding the heavier property-list
-// machinery on this path.
+// annotations and standalone compile-time kernel properties that do not need
+// the umbrella property's property-list machinery. Keep these public
+// property_value definitions here so standalone users and umbrella users
+// observe the same decltype(...) while avoiding the heavier machinery on this
+// path.
 
+#include <stddef.h>
+#include <stdint.h>
 #include <sycl/ext/oneapi/properties/property_value.hpp>
 
 #include <type_traits>
@@ -27,6 +30,73 @@ template <typename T>
 using remove_cvref_t = std::remove_cv_t<std::remove_reference_t<T>>;
 
 template <typename PropertyT> struct FunctionPropertyMetaInfo;
+template <typename PropKey, typename Properties> struct ConflictingProperties;
+
+template <size_t... Xs> struct FunctionPropertyAllNonZero {
+  static constexpr bool value = true;
+};
+template <size_t X, size_t... Xs>
+struct FunctionPropertyAllNonZero<X, Xs...> {
+  static constexpr bool value = X > 0 && FunctionPropertyAllNonZero<Xs...>::value;
+};
+
+inline constexpr size_t FunctionPropertyDecimalBase = 10;
+
+template <size_t... Sizes> struct FunctionPropertySizeList {};
+template <char... Chars> struct FunctionPropertyCharList {};
+
+template <char... Chars> struct FunctionPropertyCharsToStr {
+  static constexpr const char value[] = {Chars..., '\0'};
+};
+
+template <typename List, typename ParsedList, char... Chars>
+struct FunctionPropertySizeListToStrHelper;
+
+template <size_t Value, size_t... Values, char... ParsedChars, char... Chars>
+struct FunctionPropertySizeListToStrHelper<
+    FunctionPropertySizeList<Value, Values...>,
+    FunctionPropertyCharList<ParsedChars...>, Chars...>
+    : FunctionPropertySizeListToStrHelper<
+          FunctionPropertySizeList<Value / FunctionPropertyDecimalBase,
+                                   Values...>,
+          FunctionPropertyCharList<ParsedChars...>,
+          '0' + (Value % FunctionPropertyDecimalBase), Chars...> {};
+
+template <size_t... Values, char... ParsedChars, char... Chars>
+struct FunctionPropertySizeListToStrHelper<
+    FunctionPropertySizeList<0, Values...>,
+    FunctionPropertyCharList<ParsedChars...>, Chars...>
+    : FunctionPropertySizeListToStrHelper<
+          FunctionPropertySizeList<Values...>,
+          FunctionPropertyCharList<ParsedChars..., Chars..., ','>> {};
+
+template <size_t... Values, char... ParsedChars>
+struct FunctionPropertySizeListToStrHelper<FunctionPropertySizeList<0, Values...>,
+                                           FunctionPropertyCharList<ParsedChars...>>
+    : FunctionPropertySizeListToStrHelper<
+          FunctionPropertySizeList<Values...>,
+          FunctionPropertyCharList<ParsedChars..., '0', ','>> {};
+
+template <char... ParsedChars, char... Chars>
+struct FunctionPropertySizeListToStrHelper<FunctionPropertySizeList<0>,
+                                           FunctionPropertyCharList<ParsedChars...>,
+                                           Chars...>
+    : FunctionPropertyCharsToStr<ParsedChars..., Chars...> {};
+
+template <char... ParsedChars>
+struct FunctionPropertySizeListToStrHelper<FunctionPropertySizeList<0>,
+                                           FunctionPropertyCharList<ParsedChars...>>
+    : FunctionPropertyCharsToStr<ParsedChars..., '0'> {};
+
+template <>
+struct FunctionPropertySizeListToStrHelper<FunctionPropertySizeList<>,
+                                           FunctionPropertyCharList<>>
+    : FunctionPropertyCharsToStr<> {};
+
+template <size_t... Sizes>
+struct FunctionPropertySizeListToStr
+    : FunctionPropertySizeListToStrHelper<FunctionPropertySizeList<Sizes...>,
+                                          FunctionPropertyCharList<>> {};
 
 } // namespace detail
 
@@ -66,6 +136,162 @@ inline constexpr nd_range_kernel_key::value_t<Dims> nd_range_kernel;
 
 inline constexpr single_task_kernel_key::value_t single_task_kernel;
 
+struct work_group_size_key
+    : detail::compile_time_property_key<detail::PropKind::WorkGroupSize> {
+  template <size_t... Dims>
+  using value_t = property_value<work_group_size_key,
+                                 std::integral_constant<size_t, Dims>...>;
+};
+
+struct work_group_size_hint_key
+    : detail::compile_time_property_key<detail::PropKind::WorkGroupSizeHint> {
+  template <size_t... Dims>
+  using value_t = property_value<work_group_size_hint_key,
+                                 std::integral_constant<size_t, Dims>...>;
+};
+
+struct sub_group_size_key
+    : detail::compile_time_property_key<detail::PropKind::SubGroupSize> {
+  template <uint32_t Size>
+  using value_t = property_value<sub_group_size_key,
+                                 std::integral_constant<uint32_t, Size>>;
+};
+
+struct max_work_group_size_key
+    : detail::compile_time_property_key<detail::PropKind::MaxWorkGroupSize> {
+  template <size_t... Dims>
+  using value_t = property_value<max_work_group_size_key,
+                                 std::integral_constant<size_t, Dims>...>;
+};
+
+struct max_linear_work_group_size_key
+    : detail::compile_time_property_key<
+          detail::PropKind::MaxLinearWorkGroupSize> {
+  template <size_t Size>
+  using value_t = property_value<max_linear_work_group_size_key,
+                                 std::integral_constant<size_t, Size>>;
+};
+
+template <size_t Dim0, size_t... Dims>
+struct property_value<work_group_size_key, std::integral_constant<size_t, Dim0>,
+                      std::integral_constant<size_t, Dims>...>
+    : detail::property_base<
+          property_value<work_group_size_key,
+                         std::integral_constant<size_t, Dim0>,
+                         std::integral_constant<size_t, Dims>...>,
+          detail::PropKind::WorkGroupSize, work_group_size_key> {
+  static_assert(
+      sizeof...(Dims) + 1 <= 3,
+      "work_group_size property currently only supports up to three values.");
+  static_assert(detail::FunctionPropertyAllNonZero<Dim0, Dims...>::value,
+                "work_group_size property must only contain non-zero values.");
+
+  constexpr size_t operator[](int Dim) const {
+    constexpr size_t Values[] = {Dim0, Dims...};
+    return Values[Dim];
+  }
+
+private:
+  constexpr size_t size() const { return sizeof...(Dims) + 1; }
+
+  template <typename, typename> friend struct detail::ConflictingProperties;
+};
+
+template <size_t Dim0, size_t... Dims>
+struct property_value<work_group_size_hint_key,
+                      std::integral_constant<size_t, Dim0>,
+                      std::integral_constant<size_t, Dims>...>
+    : detail::property_base<
+          property_value<work_group_size_hint_key,
+                         std::integral_constant<size_t, Dim0>,
+                         std::integral_constant<size_t, Dims>...>,
+          detail::PropKind::WorkGroupSizeHint, work_group_size_hint_key> {
+  static_assert(sizeof...(Dims) + 1 <= 3,
+                "work_group_size_hint property currently only supports up to "
+                "three values.");
+  static_assert(
+      detail::FunctionPropertyAllNonZero<Dim0, Dims...>::value,
+      "work_group_size_hint property must only contain non-zero values.");
+
+  constexpr size_t operator[](int Dim) const {
+    constexpr size_t Values[] = {Dim0, Dims...};
+    return Values[Dim];
+  }
+};
+
+template <uint32_t Size>
+struct property_value<sub_group_size_key,
+                      std::integral_constant<uint32_t, Size>>
+    : detail::property_base<
+          property_value<sub_group_size_key,
+                         std::integral_constant<uint32_t, Size>>,
+          detail::PropKind::SubGroupSize, sub_group_size_key> {
+  static_assert(Size != 0,
+                "sub_group_size property must contain a non-zero value.");
+
+  using value_t = std::integral_constant<uint32_t, Size>;
+  static constexpr uint32_t value = Size;
+};
+
+template <size_t Dim0, size_t... Dims>
+struct property_value<max_work_group_size_key,
+                      std::integral_constant<size_t, Dim0>,
+                      std::integral_constant<size_t, Dims>...>
+    : detail::property_base<
+          property_value<max_work_group_size_key,
+                         std::integral_constant<size_t, Dim0>,
+                         std::integral_constant<size_t, Dims>...>,
+          detail::PropKind::MaxWorkGroupSize, max_work_group_size_key> {
+  static_assert(
+      sizeof...(Dims) + 1 <= 3,
+      "max_work_group_size currently only supports up to three values.");
+  static_assert(detail::FunctionPropertyAllNonZero<Dim0, Dims...>::value,
+                "max_work_group_size must only contain non-zero values.");
+
+  constexpr size_t operator[](int Dim) const {
+    constexpr size_t Values[] = {Dim0, Dims...};
+    return Values[Dim];
+  }
+
+private:
+  constexpr size_t size() const { return sizeof...(Dims) + 1; }
+
+  template <typename, typename> friend struct detail::ConflictingProperties;
+};
+
+template <size_t Size>
+struct property_value<max_linear_work_group_size_key,
+                      std::integral_constant<size_t, Size>>
+    : detail::property_base<
+          property_value<max_linear_work_group_size_key,
+                         std::integral_constant<size_t, Size>>,
+          detail::PropKind::MaxLinearWorkGroupSize,
+          max_linear_work_group_size_key> {
+  static_assert(Size != 0,
+                "max_linear_work_group_size must contain a non-zero value.");
+
+  using value_t = std::integral_constant<size_t, Size>;
+  static constexpr size_t value = Size;
+};
+
+template <size_t Dim0, size_t... Dims>
+inline constexpr work_group_size_key::value_t<Dim0, Dims...> work_group_size;
+
+template <size_t Dim0, size_t... Dims>
+inline constexpr work_group_size_hint_key::value_t<Dim0, Dims...>
+    work_group_size_hint;
+
+template <uint32_t Size>
+inline constexpr sub_group_size_key::value_t<Size> sub_group_size;
+
+template <size_t Dim0, size_t... Dims>
+inline constexpr max_work_group_size_key::value_t<Dim0, Dims...>
+    max_work_group_size;
+
+template <size_t Size>
+inline constexpr max_linear_work_group_size_key::value_t<Size>
+    max_linear_work_group_size;
+
 namespace detail {
 
 template <int Dims>
@@ -79,6 +305,85 @@ template <> struct FunctionPropertyMetaInfo<single_task_kernel_key::value_t> {
   static constexpr int value = 0;
 };
 
+template <size_t... Dims>
+struct HasCompileTimeEffect<work_group_size_key::value_t<Dims...>>
+    : std::true_type {};
+template <size_t... Dims>
+struct HasCompileTimeEffect<work_group_size_hint_key::value_t<Dims...>>
+    : std::true_type {};
+template <uint32_t Size>
+struct HasCompileTimeEffect<sub_group_size_key::value_t<Size>>
+    : std::true_type {};
+template <size_t... Dims>
+struct HasCompileTimeEffect<max_work_group_size_key::value_t<Dims...>>
+    : std::true_type {};
+template <size_t Size>
+struct HasCompileTimeEffect<max_linear_work_group_size_key::value_t<Size>>
+    : std::true_type {};
+
+template <size_t Dim0, size_t... Dims>
+struct PropertyMetaInfo<work_group_size_key::value_t<Dim0, Dims...>> {
+  static constexpr const char *name = "sycl-work-group-size";
+  static constexpr const char *value =
+      FunctionPropertySizeListToStr<Dim0, Dims...>::value;
+};
+template <size_t Dim0, size_t... Dims>
+struct FunctionPropertyMetaInfo<work_group_size_key::value_t<Dim0, Dims...>> {
+  static constexpr const char *name = "sycl-work-group-size";
+  static constexpr const char *value =
+      FunctionPropertySizeListToStr<Dim0, Dims...>::value;
+};
+
+template <size_t Dim0, size_t... Dims>
+struct PropertyMetaInfo<work_group_size_hint_key::value_t<Dim0, Dims...>> {
+  static constexpr const char *name = "sycl-work-group-size-hint";
+  static constexpr const char *value =
+      FunctionPropertySizeListToStr<Dim0, Dims...>::value;
+};
+template <size_t Dim0, size_t... Dims>
+struct FunctionPropertyMetaInfo<
+    work_group_size_hint_key::value_t<Dim0, Dims...>> {
+  static constexpr const char *name = "sycl-work-group-size-hint";
+  static constexpr const char *value =
+      FunctionPropertySizeListToStr<Dim0, Dims...>::value;
+};
+
+template <uint32_t Size>
+struct PropertyMetaInfo<sub_group_size_key::value_t<Size>> {
+  static constexpr const char *name = "sycl-sub-group-size";
+  static constexpr uint32_t value = Size;
+};
+template <uint32_t Size>
+struct FunctionPropertyMetaInfo<sub_group_size_key::value_t<Size>> {
+  static constexpr const char *name = "sycl-sub-group-size";
+  static constexpr uint32_t value = Size;
+};
+
+template <size_t Dim0, size_t... Dims>
+struct PropertyMetaInfo<max_work_group_size_key::value_t<Dim0, Dims...>> {
+  static constexpr const char *name = "sycl-max-work-group-size";
+  static constexpr const char *value =
+      FunctionPropertySizeListToStr<Dim0, Dims...>::value;
+};
+template <size_t Dim0, size_t... Dims>
+struct FunctionPropertyMetaInfo<
+    max_work_group_size_key::value_t<Dim0, Dims...>> {
+  static constexpr const char *name = "sycl-max-work-group-size";
+  static constexpr const char *value =
+      FunctionPropertySizeListToStr<Dim0, Dims...>::value;
+};
+
+template <size_t Size>
+struct PropertyMetaInfo<max_linear_work_group_size_key::value_t<Size>> {
+  static constexpr const char *name = "sycl-max-linear-work-group-size";
+  static constexpr size_t value = Size;
+};
+template <size_t Size>
+struct FunctionPropertyMetaInfo<max_linear_work_group_size_key::value_t<Size>> {
+  static constexpr const char *name = "sycl-max-linear-work-group-size";
+  static constexpr size_t value = Size;
+};
+
 } // namespace detail
 } // namespace ext::oneapi::experimental
 } // namespace _V1
@@ -95,4 +400,4 @@ template <> struct FunctionPropertyMetaInfo<single_task_kernel_key::value_t> {
               decltype(PROP)>>::value)]]
 #else
 #define SYCL_EXT_ONEAPI_FUNCTION_PROPERTY(PROP)
-#endif
\ No newline at end of file
+#endif
diff --git a/sycl/include/sycl/ext/oneapi/kernel_properties/properties.hpp b/sycl/include/sycl/ext/oneapi/kernel_properties/properties.hpp
index 16cf6aed572b8..b26d68a4d3be1 100644
--- a/sycl/include/sycl/ext/oneapi/kernel_properties/properties.hpp
+++ b/sycl/include/sycl/ext/oneapi/kernel_properties/properties.hpp
@@ -13,7 +13,7 @@
 #include <stdint.h>                                          // for uint32_t
 #include <sycl/aspects.hpp>                                  // for aspect
 #include <sycl/ext/oneapi/experimental/forward_progress.hpp> // for forward_progress_guarantee enum
-#include <sycl/ext/oneapi/kernel_properties/function_launch_properties.hpp>
+#include <sycl/ext/oneapi/kernel_properties/function_properties.hpp>
 #include <sycl/ext/oneapi/properties/properties.hpp>
 #include <type_traits>                                   // for true_type
 #include <utility>                                       // for declval
diff --git a/sycl/test/extensions/properties/function_properties_split.cpp b/sycl/test/extensions/properties/function_properties_split.cpp
new file mode 100644
index 0000000000000..c72d27b1c115d
--- /dev/null
+++ b/sycl/test/extensions/properties/function_properties_split.cpp
@@ -0,0 +1,37 @@
+// RUN: %clangxx -fsycl -fsycl-targets=%sycl_triple -fsyntax-only -I %sycl_source_dir/include -I %sycl_include %s
+// expected-no-diagnostics
+
+#include <sycl/ext/oneapi/kernel_properties/function_properties.hpp>
+
+#include <type_traits>
+
+using namespace sycl::ext::oneapi::experimental;
+
+int main() {
+  static_assert(is_property_value<decltype(nd_range_kernel<1>)>::value);
+  static_assert(is_property_value<decltype(single_task_kernel)>::value);
+  static_assert(is_property_value<decltype(work_group_size<2, 3>)>::value);
+  static_assert(is_property_value<decltype(work_group_size_hint<4, 5, 6>)>::value);
+  static_assert(is_property_value<decltype(sub_group_size<7>)>::value);
+  static_assert(is_property_value<decltype(max_work_group_size<8, 9>)>::value);
+  static_assert(is_property_value<decltype(max_linear_work_group_size<10>)>::value);
+
+  static_assert(work_group_size<2, 3>[0] == 2);
+  static_assert(work_group_size<2, 3>[1] == 3);
+  static_assert(work_group_size_hint<4, 5, 6>[2] == 6);
+  static_assert(sub_group_size<7>.value == 7);
+  static_assert(max_work_group_size<8, 9>[1] == 9);
+  static_assert(max_linear_work_group_size<10>.value == 10);
+
+  static_assert(std::is_same_v<decltype(work_group_size<2, 3>)::key_t,
+                               work_group_size_key>);
+  static_assert(std::is_same_v<decltype(work_group_size_hint<4>)::key_t,
+                               work_group_size_hint_key>);
+  static_assert(std::is_same_v<decltype(sub_group_size<7>)::key_t,
+                               sub_group_size_key>);
+  static_assert(std::is_same_v<decltype(max_work_group_size<8>)::key_t,
+                               max_work_group_size_key>);
+  static_assert(std::is_same_v<decltype(max_linear_work_group_size<10>)::key_t,
+                               max_linear_work_group_size_key>);
+  return 0;
+}
diff --git a/sycl/test/extensions/properties/properties_kernel_negative.cpp b/sycl/test/extensions/properties/properties_kernel_negative.cpp
index 27dac354dca74..3ee88369079fa 100644
--- a/sycl/test/extensions/properties/properties_kernel_negative.cpp
+++ b/sycl/test/extensions/properties/properties_kernel_negative.cpp
@@ -30,53 +30,53 @@ void check_work_group_size() {
   // expected-error@+1 {{too few template arguments for variable template 'work_group_size'}}
   auto WGSize0 = sycl::ext::oneapi::experimental::work_group_size<>;
 
-  // expected-error-re@sycl/ext/oneapi/kernel_properties/function_launch_properties.hpp:* {{static assertion failed due to requirement {{.+}}: work_group_size property must only contain non-zero values.}}
-  // expected-error@sycl/ext/oneapi/kernel_properties/function_launch_properties.hpp:* {{constexpr variable 'work_group_size<0>' must be initialized by a constant expression}}
+  // expected-error-re@sycl/ext/oneapi/kernel_properties/function_properties.hpp:* {{static assertion failed due to requirement {{.+}}: work_group_size property must only contain non-zero values.}}
+  // expected-error@sycl/ext/oneapi/kernel_properties/function_properties.hpp:* {{constexpr variable 'work_group_size<0>' must be initialized by a constant expression}}
   // expected-note@+1 {{in instantiation of variable template specialization 'sycl::ext::oneapi::experimental::work_group_size<0>' requested here}}
   auto WGSize1 = sycl::ext::oneapi::experimental::work_group_size<0>;
-  // expected-error-re@sycl/ext/oneapi/kernel_properties/function_launch_properties.hpp:* {{static assertion failed due to requirement {{.+}}: work_group_size property must only contain non-zero values.}}
-  // expected-error@sycl/ext/oneapi/kernel_properties/function_launch_properties.hpp:* {{constexpr variable 'work_group_size<0, 0>' must be initialized by a constant expression}}
+  // expected-error-re@sycl/ext/oneapi/kernel_properties/function_properties.hpp:* {{static assertion failed due to requirement {{.+}}: work_group_size property must only contain non-zero values.}}
+  // expected-error@sycl/ext/oneapi/kernel_properties/function_properties.hpp:* {{constexpr variable 'work_group_size<0, 0>' must be initialized by a constant expression}}
   // expected-note@+1 {{in instantiation of variable template specialization 'sycl::ext::oneapi::experimental::work_group_size<0, 0>' requested here}}
   auto WGSize2 = sycl::ext::oneapi::experimental::work_group_size<0, 0>;
-  // expected-error-re@sycl/ext/oneapi/kernel_properties/function_launch_properties.hpp:* {{static assertion failed due to requirement {{.+}}: work_group_size property must only contain non-zero values.}}
-  // expected-error@sycl/ext/oneapi/kernel_properties/function_launch_properties.hpp:* {{constexpr variable 'work_group_size<1, 0>' must be initialized by a constant expression}}
+  // expected-error-re@sycl/ext/oneapi/kernel_properties/function_properties.hpp:* {{static assertion failed due to requirement {{.+}}: work_group_size property must only contain non-zero values.}}
+  // expected-error@sycl/ext/oneapi/kernel_properties/function_properties.hpp:* {{constexpr variable 'work_group_size<1, 0>' must be initialized by a constant expression}}
   // expected-note@+1 {{in instantiation of variable template specialization 'sycl::ext::oneapi::experimental::work_group_size<1, 0>' requested here}}
   auto WGSize3 = sycl::ext::oneapi::experimental::work_group_size<1, 0>;
-  // expected-error-re@sycl/ext/oneapi/kernel_properties/function_launch_properties.hpp:* {{static assertion failed due to requirement {{.+}}: work_group_size property must only contain non-zero values.}}
-  // expected-error@sycl/ext/oneapi/kernel_properties/function_launch_properties.hpp:* {{constexpr variable 'work_group_size<0, 1>' must be initialized by a constant expression}}
+  // expected-error-re@sycl/ext/oneapi/kernel_properties/function_properties.hpp:* {{static assertion failed due to requirement {{.+}}: work_group_size property must only contain non-zero values.}}
+  // expected-error@sycl/ext/oneapi/kernel_properties/function_properties.hpp:* {{constexpr variable 'work_group_size<0, 1>' must be initialized by a constant expression}}
   // expected-note@+1 {{in instantiation of variable template specialization 'sycl::ext::oneapi::experimental::work_group_size<0, 1>' requested here}}
   auto WGSize4 = sycl::ext::oneapi::experimental::work_group_size<0, 1>;
-  // expected-error-re@sycl/ext/oneapi/kernel_properties/function_launch_properties.hpp:* {{static assertion failed due to requirement {{.+}}: work_group_size property must only contain non-zero values.}}
-  // expected-error@sycl/ext/oneapi/kernel_properties/function_launch_properties.hpp:* {{constexpr variable 'work_group_size<0, 0, 0>' must be initialized by a constant expression}}
+  // expected-error-re@sycl/ext/oneapi/kernel_properties/function_properties.hpp:* {{static assertion failed due to requirement {{.+}}: work_group_size property must only contain non-zero values.}}
+  // expected-error@sycl/ext/oneapi/kernel_properties/function_properties.hpp:* {{constexpr variable 'work_group_size<0, 0, 0>' must be initialized by a constant expression}}
   // expected-note@+1 {{in instantiation of variable template specialization 'sycl::ext::oneapi::experimental::work_group_size<0, 0, 0>' requested here}}
   auto WGSize5 = sycl::ext::oneapi::experimental::work_group_size<0, 0, 0>;
-  // expected-error-re@sycl/ext/oneapi/kernel_properties/function_launch_properties.hpp:* {{static assertion failed due to requirement {{.+}}: work_group_size property must only contain non-zero values.}}
-  // expected-error@sycl/ext/oneapi/kernel_properties/function_launch_properties.hpp:* {{constexpr variable 'work_group_size<1, 0, 0>' must be initialized by a constant expression}}
+  // expected-error-re@sycl/ext/oneapi/kernel_properties/function_properties.hpp:* {{static assertion failed due to requirement {{.+}}: work_group_size property must only contain non-zero values.}}
+  // expected-error@sycl/ext/oneapi/kernel_properties/function_properties.hpp:* {{constexpr variable 'work_group_size<1, 0, 0>' must be initialized by a constant expression}}
   // expected-note@+1 {{in instantiation of variable template specialization 'sycl::ext::oneapi::experimental::work_group_size<1, 0, 0>' requested here}}
   auto WGSize6 = sycl::ext::oneapi::experimental::work_group_size<1, 0, 0>;
-  // expected-error-re@sycl/ext/oneapi/kernel_properties/function_launch_properties.hpp:* {{static assertion failed due to requirement {{.+}}: work_group_size property must only contain non-zero values.}}
-  // expected-error@sycl/ext/oneapi/kernel_properties/function_launch_properties.hpp:* {{constexpr variable 'work_group_size<0, 1, 0>' must be initialized by a constant expression}}
+  // expected-error-re@sycl/ext/oneapi/kernel_properties/function_properties.hpp:* {{static assertion failed due to requirement {{.+}}: work_group_size property must only contain non-zero values.}}
+  // expected-error@sycl/ext/oneapi/kernel_properties/function_properties.hpp:* {{constexpr variable 'work_group_size<0, 1, 0>' must be initialized by a constant expression}}
   // expected-note@+1 {{in instantiation of variable template specialization 'sycl::ext::oneapi::experimental::work_group_size<0, 1, 0>' requested here}}
   auto WGSize7 = sycl::ext::oneapi::experimental::work_group_size<0, 1, 0>;
-  // expected-error-re@sycl/ext/oneapi/kernel_properties/function_launch_properties.hpp:* {{static assertion failed due to requirement {{.+}}: work_group_size property must only contain non-zero values.}}
-  // expected-error@sycl/ext/oneapi/kernel_properties/function_launch_properties.hpp:* {{constexpr variable 'work_group_size<0, 0, 1>' must be initialized by a constant expression}}
+  // expected-error-re@sycl/ext/oneapi/kernel_properties/function_properties.hpp:* {{static assertion failed due to requirement {{.+}}: work_group_size property must only contain non-zero values.}}
+  // expected-error@sycl/ext/oneapi/kernel_properties/function_properties.hpp:* {{constexpr variable 'work_group_size<0, 0, 1>' must be initialized by a constant expression}}
   // expected-note@+1 {{in instantiation of variable template specialization 'sycl::ext::oneapi::experimental::work_group_size<0, 0, 1>' requested here}}
   auto WGSize8 = sycl::ext::oneapi::experimental::work_group_size<0, 0, 1>;
-  // expected-error-re@sycl/ext/oneapi/kernel_properties/function_launch_properties.hpp:* {{static assertion failed due to requirement {{.+}}: work_group_size property must only contain non-zero values.}}
-  // expected-error@sycl/ext/oneapi/kernel_properties/function_launch_properties.hpp:* {{constexpr variable 'work_group_size<1, 1, 0>' must be initialized by a constant expression}}
+  // expected-error-re@sycl/ext/oneapi/kernel_properties/function_properties.hpp:* {{static assertion failed due to requirement {{.+}}: work_group_size property must only contain non-zero values.}}
+  // expected-error@sycl/ext/oneapi/kernel_properties/function_properties.hpp:* {{constexpr variable 'work_group_size<1, 1, 0>' must be initialized by a constant expression}}
   // expected-note@+1 {{in instantiation of variable template specialization 'sycl::ext::oneapi::experimental::work_group_size<1, 1, 0>' requested here}}
   auto WGSize9 = sycl::ext::oneapi::experimental::work_group_size<1, 1, 0>;
-  // expected-error-re@sycl/ext/oneapi/kernel_properties/function_launch_properties.hpp:* {{static assertion failed due to requirement {{.+}}: work_group_size property must only contain non-zero values.}}
-  // expected-error@sycl/ext/oneapi/kernel_properties/function_launch_properties.hpp:* {{constexpr variable 'work_group_size<0, 1, 1>' must be initialized by a constant expression}}
+  // expected-error-re@sycl/ext/oneapi/kernel_properties/function_properties.hpp:* {{static assertion failed due to requirement {{.+}}: work_group_size property must only contain non-zero values.}}
+  // expected-error@sycl/ext/oneapi/kernel_properties/function_properties.hpp:* {{constexpr variable 'work_group_size<0, 1, 1>' must be initialized by a constant expression}}
   // expected-note@+1 {{in instantiation of variable template specialization 'sycl::ext::oneapi::experimental::work_group_size<0, 1, 1>' requested here}}
   auto WGSize10 = sycl::ext::oneapi::experimental::work_group_size<0, 1, 1>;
-  // expected-error-re@sycl/ext/oneapi/kernel_properties/function_launch_properties.hpp:* {{static assertion failed due to requirement {{.+}}: work_group_size property must only contain non-zero values.}}
-  // expected-error@sycl/ext/oneapi/kernel_properties/function_launch_properties.hpp:* {{constexpr variable 'work_group_size<1, 0, 1>' must be initialized by a constant expression}}
+  // expected-error-re@sycl/ext/oneapi/kernel_properties/function_properties.hpp:* {{static assertion failed due to requirement {{.+}}: work_group_size property must only contain non-zero values.}}
+  // expected-error@sycl/ext/oneapi/kernel_properties/function_properties.hpp:* {{constexpr variable 'work_group_size<1, 0, 1>' must be initialized by a constant expression}}
   // expected-note@+1 {{in instantiation of variable template specialization 'sycl::ext::oneapi::experimental::work_group_size<1, 0, 1>' requested here}}
   auto WGSize11 = sycl::ext::oneapi::experimental::work_group_size<1, 0, 1>;
 
-  // expected-error-re@sycl/ext/oneapi/kernel_properties/function_launch_properties.hpp:* {{static assertion failed due to requirement {{.+}}: work_group_size property currently only supports up to three values.}}
-  // expected-error@sycl/ext/oneapi/kernel_properties/function_launch_properties.hpp:* {{constexpr variable 'work_group_size<1, 1, 1, 1>' must be initialized by a constant expression}}
+  // expected-error-re@sycl/ext/oneapi/kernel_properties/function_properties.hpp:* {{static assertion failed due to requirement {{.+}}: work_group_size property currently only supports up to three values.}}
+  // expected-error@sycl/ext/oneapi/kernel_properties/function_properties.hpp:* {{constexpr variable 'work_group_size<1, 1, 1, 1>' must be initialized by a constant expression}}
   // expected-note@+1 {{in instantiation of variable template specialization 'sycl::ext::oneapi::experimental::work_group_size<1, 1, 1, 1>' requested here}}
   auto WGSize12 = sycl::ext::oneapi::experimental::work_group_size<1, 1, 1, 1>;
 
@@ -164,55 +164,55 @@ void check_work_group_size_hint() {
   // expected-error@+1 {{too few template arguments for variable template 'work_group_size_hint'}}
   auto WGSize0 = sycl::ext::oneapi::experimental::work_group_size_hint<>;
 
-  // expected-error-re@sycl/ext/oneapi/kernel_properties/function_launch_properties.hpp:* {{static assertion failed due to requirement {{.+}}: work_group_size_hint property must only contain non-zero values.}}
-  // expected-error@sycl/ext/oneapi/kernel_properties/function_launch_properties.hpp:* {{constexpr variable 'work_group_size_hint<0>' must be initialized by a constant expression}}
+  // expected-error-re@sycl/ext/oneapi/kernel_properties/function_properties.hpp:* {{static assertion failed due to requirement {{.+}}: work_group_size_hint property must only contain non-zero values.}}
+  // expected-error@sycl/ext/oneapi/kernel_properties/function_properties.hpp:* {{constexpr variable 'work_group_size_hint<0>' must be initialized by a constant expression}}
   // expected-note@+1 {{in instantiation of variable template specialization 'sycl::ext::oneapi::experimental::work_group_size_hint<0>' requested here}}
   auto WGSize1 = sycl::ext::oneapi::experimental::work_group_size_hint<0>;
-  // expected-error-re@sycl/ext/oneapi/kernel_properties/function_launch_properties.hpp:* {{static assertion failed due to requirement {{.+}}: work_group_size_hint property must only contain non-zero values.}}
-  // expected-error@sycl/ext/oneapi/kernel_properties/function_launch_properties.hpp:* {{constexpr variable 'work_group_size_hint<0, 0>' must be initialized by a constant expression}}
+  // expected-error-re@sycl/ext/oneapi/kernel_properties/function_properties.hpp:* {{static assertion failed due to requirement {{.+}}: work_group_size_hint property must only contain non-zero values.}}
+  // expected-error@sycl/ext/oneapi/kernel_properties/function_properties.hpp:* {{constexpr variable 'work_group_size_hint<0, 0>' must be initialized by a constant expression}}
   // expected-note@+1 {{in instantiation of variable template specialization 'sycl::ext::oneapi::experimental::work_group_size_hint<0, 0>' requested here}}
   auto WGSize2 = sycl::ext::oneapi::experimental::work_group_size_hint<0, 0>;
-  // expected-error-re@sycl/ext/oneapi/kernel_properties/function_launch_properties.hpp:* {{static assertion failed due to requirement {{.+}}: work_group_size_hint property must only contain non-zero values.}}
-  // expected-error@sycl/ext/oneapi/kernel_properties/function_launch_properties.hpp:* {{constexpr variable 'work_group_size_hint<1, 0>' must be initialized by a constant expression}}
+  // expected-error-re@sycl/ext/oneapi/kernel_properties/function_properties.hpp:* {{static assertion failed due to requirement {{.+}}: work_group_size_hint property must only contain non-zero values.}}
+  // expected-error@sycl/ext/oneapi/kernel_properties/function_properties.hpp:* {{constexpr variable 'work_group_size_hint<1, 0>' must be initialized by a constant expression}}
   // expected-note@+1 {{in instantiation of variable template specialization 'sycl::ext::oneapi::experimental::work_group_size_hint<1, 0>' requested here}}
   auto WGSize3 = sycl::ext::oneapi::experimental::work_group_size_hint<1, 0>;
-  // expected-error-re@sycl/ext/oneapi/kernel_properties/function_launch_properties.hpp:* {{static assertion failed due to requirement {{.+}}: work_group_size_hint property must only contain non-zero values.}}
-  // expected-error@sycl/ext/oneapi/kernel_properties/function_launch_properties.hpp:* {{constexpr variable 'work_group_size_hint<0, 1>' must be initialized by a constant expression}}
+  // expected-error-re@sycl/ext/oneapi/kernel_properties/function_properties.hpp:* {{static assertion failed due to requirement {{.+}}: work_group_size_hint property must only contain non-zero values.}}
+  // expected-error@sycl/ext/oneapi/kernel_properties/function_properties.hpp:* {{constexpr variable 'work_group_size_hint<0, 1>' must be initialized by a constant expression}}
   // expected-note@+1 {{in instantiation of variable template specialization 'sycl::ext::oneapi::experimental::work_group_size_hint<0, 1>' requested here}}
   auto WGSize4 = sycl::ext::oneapi::experimental::work_group_size_hint<0, 1>;
-  // expected-error-re@sycl/ext/oneapi/kernel_properties/function_launch_properties.hpp:* {{static assertion failed due to requirement {{.+}}: work_group_size_hint property must only contain non-zero values.}}
-  // expected-error@sycl/ext/oneapi/kernel_properties/function_launch_properties.hpp:* {{constexpr variable 'work_group_size_hint<0, 0, 0>' must be initialized by a constant expression}}
+  // expected-error-re@sycl/ext/oneapi/kernel_properties/function_properties.hpp:* {{static assertion failed due to requirement {{.+}}: work_group_size_hint property must only contain non-zero values.}}
+  // expected-error@sycl/ext/oneapi/kernel_properties/function_properties.hpp:* {{constexpr variable 'work_group_size_hint<0, 0, 0>' must be initialized by a constant expression}}
   // expected-note@+1 {{in instantiation of variable template specialization 'sycl::ext::oneapi::experimental::work_group_size_hint<0, 0, 0>' requested here}}
   auto WGSize5 = sycl::ext::oneapi::experimental::work_group_size_hint<0, 0, 0>;
-  // expected-error-re@sycl/ext/oneapi/kernel_properties/function_launch_properties.hpp:* {{static assertion failed due to requirement {{.+}}: work_group_size_hint property must only contain non-zero values.}}
-  // expected-error@sycl/ext/oneapi/kernel_properties/function_launch_properties.hpp:* {{constexpr variable 'work_group_size_hint<1, 0, 0>' must be initialized by a constant expression}}
+  // expected-error-re@sycl/ext/oneapi/kernel_properties/function_properties.hpp:* {{static assertion failed due to requirement {{.+}}: work_group_size_hint property must only contain non-zero values.}}
+  // expected-error@sycl/ext/oneapi/kernel_properties/function_properties.hpp:* {{constexpr variable 'work_group_size_hint<1, 0, 0>' must be initialized by a constant expression}}
   // expected-note@+1 {{in instantiation of variable template specialization 'sycl::ext::oneapi::experimental::work_group_size_hint<1, 0, 0>' requested here}}
   auto WGSize6 = sycl::ext::oneapi::experimental::work_group_size_hint<1, 0, 0>;
-  // expected-error-re@sycl/ext/oneapi/kernel_properties/function_launch_properties.hpp:* {{static assertion failed due to requirement {{.+}}: work_group_size_hint property must only contain non-zero values.}}
-  // expected-error@sycl/ext/oneapi/kernel_properties/function_launch_properties.hpp:* {{constexpr variable 'work_group_size_hint<0, 1, 0>' must be initialized by a constant expression}}
+  // expected-error-re@sycl/ext/oneapi/kernel_properties/function_properties.hpp:* {{static assertion failed due to requirement {{.+}}: work_group_size_hint property must only contain non-zero values.}}
+  // expected-error@sycl/ext/oneapi/kernel_properties/function_properties.hpp:* {{constexpr variable 'work_group_size_hint<0, 1, 0>' must be initialized by a constant expression}}
   // expected-note@+1 {{in instantiation of variable template specialization 'sycl::ext::oneapi::experimental::work_group_size_hint<0, 1, 0>' requested here}}
   auto WGSize7 = sycl::ext::oneapi::experimental::work_group_size_hint<0, 1, 0>;
-  // expected-error-re@sycl/ext/oneapi/kernel_properties/function_launch_properties.hpp:* {{static assertion failed due to requirement {{.+}}: work_group_size_hint property must only contain non-zero values.}}
-  // expected-error@sycl/ext/oneapi/kernel_properties/function_launch_properties.hpp:* {{constexpr variable 'work_group_size_hint<0, 0, 1>' must be initialized by a constant expression}}
+  // expected-error-re@sycl/ext/oneapi/kernel_properties/function_properties.hpp:* {{static assertion failed due to requirement {{.+}}: work_group_size_hint property must only contain non-zero values.}}
+  // expected-error@sycl/ext/oneapi/kernel_properties/function_properties.hpp:* {{constexpr variable 'work_group_size_hint<0, 0, 1>' must be initialized by a constant expression}}
   // expected-note@+1 {{in instantiation of variable template specialization 'sycl::ext::oneapi::experimental::work_group_size_hint<0, 0, 1>' requested here}}
   auto WGSize8 = sycl::ext::oneapi::experimental::work_group_size_hint<0, 0, 1>;
-  // expected-error-re@sycl/ext/oneapi/kernel_properties/function_launch_properties.hpp:* {{static assertion failed due to requirement {{.+}}: work_group_size_hint property must only contain non-zero values.}}
-  // expected-error@sycl/ext/oneapi/kernel_properties/function_launch_properties.hpp:* {{constexpr variable 'work_group_size_hint<1, 1, 0>' must be initialized by a constant expression}}
+  // expected-error-re@sycl/ext/oneapi/kernel_properties/function_properties.hpp:* {{static assertion failed due to requirement {{.+}}: work_group_size_hint property must only contain non-zero values.}}
+  // expected-error@sycl/ext/oneapi/kernel_properties/function_properties.hpp:* {{constexpr variable 'work_group_size_hint<1, 1, 0>' must be initialized by a constant expression}}
   // expected-note@+1 {{in instantiation of variable template specialization 'sycl::ext::oneapi::experimental::work_group_size_hint<1, 1, 0>' requested here}}
   auto WGSize9 = sycl::ext::oneapi::experimental::work_group_size_hint<1, 1, 0>;
-  // expected-error-re@sycl/ext/oneapi/kernel_properties/function_launch_properties.hpp:* {{static assertion failed due to requirement {{.+}}: work_group_size_hint property must only contain non-zero values.}}
-  // expected-error@sycl/ext/oneapi/kernel_properties/function_launch_properties.hpp:* {{constexpr variable 'work_group_size_hint<0, 1, 1>' must be initialized by a constant expression}}
+  // expected-error-re@sycl/ext/oneapi/kernel_properties/function_properties.hpp:* {{static assertion failed due to requirement {{.+}}: work_group_size_hint property must only contain non-zero values.}}
+  // expected-error@sycl/ext/oneapi/kernel_properties/function_properties.hpp:* {{constexpr variable 'work_group_size_hint<0, 1, 1>' must be initialized by a constant expression}}
   // expected-note@+2 {{in instantiation of variable template specialization 'sycl::ext::oneapi::experimental::work_group_size_hint<0, 1, 1>' requested here}}
   auto WGSize10 =
       sycl::ext::oneapi::experimental::work_group_size_hint<0, 1, 1>;
-  // expected-error-re@sycl/ext/oneapi/kernel_properties/function_launch_properties.hpp:* {{static assertion failed due to requirement {{.+}}: work_group_size_hint property must only contain non-zero values.}}
-  // expected-error@sycl/ext/oneapi/kernel_properties/function_launch_properties.hpp:* {{constexpr variable 'work_group_size_hint<1, 0, 1>' must be initialized by a constant expression}}
+  // expected-error-re@sycl/ext/oneapi/kernel_properties/function_properties.hpp:* {{static assertion failed due to requirement {{.+}}: work_group_size_hint property must only contain non-zero values.}}
+  // expected-error@sycl/ext/oneapi/kernel_properties/function_properties.hpp:* {{constexpr variable 'work_group_size_hint<1, 0, 1>' must be initialized by a constant expression}}
   // expected-note@+2 {{in instantiation of variable template specialization 'sycl::ext::oneapi::experimental::work_group_size_hint<1, 0, 1>' requested here}}
   auto WGSize11 =
       sycl::ext::oneapi::experimental::work_group_size_hint<1, 0, 1>;
 
-  // expected-error-re@sycl/ext/oneapi/kernel_properties/function_launch_properties.hpp:* {{static assertion failed due to requirement {{.+}}: work_group_size_hint property currently only supports up to three values.}}
-  // expected-error@sycl/ext/oneapi/kernel_properties/function_launch_properties.hpp:* {{constexpr variable 'work_group_size_hint<1, 1, 1, 1>' must be initialized by a constant expression}}
+  // expected-error-re@sycl/ext/oneapi/kernel_properties/function_properties.hpp:* {{static assertion failed due to requirement {{.+}}: work_group_size_hint property currently only supports up to three values.}}
+  // expected-error@sycl/ext/oneapi/kernel_properties/function_properties.hpp:* {{constexpr variable 'work_group_size_hint<1, 1, 1, 1>' must be initialized by a constant expression}}
   // expected-note@+2 {{in instantiation of variable template specialization 'sycl::ext::oneapi::experimental::work_group_size_hint<1, 1, 1, 1>' requested here}}
   auto WGSize12 =
       sycl::ext::oneapi::experimental::work_group_size_hint<1, 1, 1, 1>;
@@ -301,8 +301,8 @@ void check_sub_group_size() {
   // expected-error@+1 {{too few template arguments for variable template 'sub_group_size'}}
   auto WGSize0 = sycl::ext::oneapi::experimental::sub_group_size<>;
 
-  // expected-error-re@sycl/ext/oneapi/kernel_properties/function_launch_properties.hpp:* {{static assertion failed due to requirement {{.+}}: sub_group_size property must contain a non-zero value.}}
-  // expected-error@sycl/ext/oneapi/kernel_properties/function_launch_properties.hpp:* {{constexpr variable 'sub_group_size<0>' must be initialized by a constant expression}}
+  // expected-error-re@sycl/ext/oneapi/kernel_properties/function_properties.hpp:* {{static assertion failed due to requirement {{.+}}: sub_group_size property must contain a non-zero value.}}
+  // expected-error@sycl/ext/oneapi/kernel_properties/function_properties.hpp:* {{constexpr variable 'sub_group_size<0>' must be initialized by a constant expression}}
   // expected-note@+1 {{in instantiation of variable template specialization 'sycl::ext::oneapi::experimental::sub_group_size<0>' requested here}}
   auto WGSize1 = sycl::ext::oneapi::experimental::sub_group_size<0>;
 
diff --git a/sycl/test/include_deps/sycl_detail_core.hpp.cpp b/sycl/test/include_deps/sycl_detail_core.hpp.cpp
index 1aa2adc6b740b..72d93643164a2 100644
--- a/sycl/test/include_deps/sycl_detail_core.hpp.cpp
+++ b/sycl/test/include_deps/sycl_detail_core.hpp.cpp
@@ -113,7 +113,6 @@
 // CHECK-NEXT: device_selector.hpp
 // CHECK-NEXT: kernel_bundle_enums.hpp
 // CHECK-NEXT: ext/oneapi/kernel_properties/properties.hpp
-// CHECK-NEXT: ext/oneapi/kernel_properties/function_launch_properties.hpp
 // CHECK-NEXT: ext/oneapi/kernel_properties/function_properties.hpp
 // CHECK-NEXT: ext/oneapi/properties/property_value.hpp
 // CHECK-NEXT: ext/oneapi/properties/property.hpp
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 7194a1acf4c80..7f19980446c7d 100644
--- a/sycl/test/include_deps/sycl_khr_includes_handler.hpp.cpp
+++ b/sycl/test/include_deps/sycl_khr_includes_handler.hpp.cpp
@@ -137,7 +137,6 @@
 // CHECK-NEXT: ext/oneapi/experimental/virtual_functions.hpp
 // CHECK-NEXT: ext/oneapi/kernel_properties/function_properties.hpp
 // CHECK-NEXT: ext/oneapi/kernel_properties/properties.hpp
-// CHECK-NEXT: ext/oneapi/kernel_properties/function_launch_properties.hpp
 // CHECK-NEXT: ext/oneapi/work_group_scratch_memory.hpp
 // CHECK-NEXT: detail/sycl_local_mem_builtins.hpp
 // CHECK-NEXT: detail/nd_range_view.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 edabb605d9ff3..4e7588112ff91 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
@@ -145,7 +145,6 @@
 // CHECK-NEXT: ext/oneapi/experimental/virtual_functions.hpp
 // CHECK-NEXT: ext/oneapi/kernel_properties/function_properties.hpp
 // CHECK-NEXT: ext/oneapi/kernel_properties/properties.hpp
-// CHECK-NEXT: ext/oneapi/kernel_properties/function_launch_properties.hpp
 // CHECK-NEXT: ext/oneapi/work_group_scratch_memory.hpp
 // CHECK-NEXT: detail/sycl_local_mem_builtins.hpp
 // CHECK-NEXT: detail/nd_range_view.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 ea7d66f1d650c..954e8906be1de 100644
--- a/sycl/test/include_deps/sycl_khr_includes_queue.hpp.cpp
+++ b/sycl/test/include_deps/sycl_khr_includes_queue.hpp.cpp
@@ -117,7 +117,6 @@
 // CHECK-NEXT: device_selector.hpp
 // CHECK-NEXT: kernel_bundle_enums.hpp
 // CHECK-NEXT: ext/oneapi/kernel_properties/properties.hpp
-// CHECK-NEXT: ext/oneapi/kernel_properties/function_launch_properties.hpp
 // CHECK-NEXT: ext/oneapi/kernel_properties/function_properties.hpp
 // CHECK-NEXT: ext/oneapi/properties/property_value.hpp
 // CHECK-NEXT: ext/oneapi/properties/property.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 90bd4c21c51f6..a3db1523e08d5 100644
--- a/sycl/test/include_deps/sycl_khr_includes_reduction.hpp.cpp
+++ b/sycl/test/include_deps/sycl_khr_includes_reduction.hpp.cpp
@@ -174,7 +174,6 @@
 // CHECK-NEXT: ext/oneapi/experimental/virtual_functions.hpp
 // CHECK-NEXT: ext/oneapi/kernel_properties/function_properties.hpp
 // CHECK-NEXT: ext/oneapi/kernel_properties/properties.hpp
-// CHECK-NEXT: ext/oneapi/kernel_properties/function_launch_properties.hpp
 // CHECK-NEXT: ext/oneapi/work_group_scratch_memory.hpp
 // CHECK-NEXT: detail/sycl_local_mem_builtins.hpp
 // CHECK-NEXT: detail/nd_range_view.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 abfcf488bf61e..166c8c70a4299 100644
--- a/sycl/test/include_deps/sycl_khr_includes_stream.hpp.cpp
+++ b/sycl/test/include_deps/sycl_khr_includes_stream.hpp.cpp
@@ -155,7 +155,6 @@
 // CHECK-NEXT: ext/oneapi/experimental/virtual_functions.hpp
 // CHECK-NEXT: ext/oneapi/kernel_properties/function_properties.hpp
 // CHECK-NEXT: ext/oneapi/kernel_properties/properties.hpp
-// CHECK-NEXT: ext/oneapi/kernel_properties/function_launch_properties.hpp
 // CHECK-NEXT: ext/oneapi/work_group_scratch_memory.hpp
 // CHECK-NEXT: detail/sycl_local_mem_builtins.hpp
 // CHECK-NEXT: detail/nd_range_view.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 a646ff9e4bd3a..1478ac6895dc8 100644
--- a/sycl/test/include_deps/sycl_khr_includes_usm.hpp.cpp
+++ b/sycl/test/include_deps/sycl_khr_includes_usm.hpp.cpp
@@ -132,7 +132,6 @@
 // CHECK-NEXT: detail/optional.hpp
 // CHECK-NEXT: detail/range_rounding.hpp
 // CHECK-NEXT: ext/oneapi/kernel_properties/properties.hpp
-// CHECK-NEXT: ext/oneapi/kernel_properties/function_launch_properties.hpp
 // CHECK-NEXT: ext/oneapi/kernel_properties/function_properties.hpp
 // CHECK-NEXT: ext/oneapi/properties/property_value.hpp
 // CHECK-NEXT: ext/oneapi/properties/property.hpp

From c17bca0468d4a915bfeb51ec873bf1794cd350a7 Mon Sep 17 00:00:00 2001
From: y <konstantinos.parasyris@intel.com>
Date: Tue, 14 Apr 2026 12:02:32 -0700
Subject: [PATCH 03/11] fix formatting

---
 .../kernel_properties/function_properties.hpp | 22 +++++++++----------
 .../properties/function_properties_split.cpp  | 10 +++++----
 2 files changed, 17 insertions(+), 15 deletions(-)

diff --git a/sycl/include/sycl/ext/oneapi/kernel_properties/function_properties.hpp b/sycl/include/sycl/ext/oneapi/kernel_properties/function_properties.hpp
index dda6371583db6..bd2d7b8c41172 100644
--- a/sycl/include/sycl/ext/oneapi/kernel_properties/function_properties.hpp
+++ b/sycl/include/sycl/ext/oneapi/kernel_properties/function_properties.hpp
@@ -35,9 +35,9 @@ template <typename PropKey, typename Properties> struct ConflictingProperties;
 template <size_t... Xs> struct FunctionPropertyAllNonZero {
   static constexpr bool value = true;
 };
-template <size_t X, size_t... Xs>
-struct FunctionPropertyAllNonZero<X, Xs...> {
-  static constexpr bool value = X > 0 && FunctionPropertyAllNonZero<Xs...>::value;
+template <size_t X, size_t... Xs> struct FunctionPropertyAllNonZero<X, Xs...> {
+  static constexpr bool value =
+      X > 0 && FunctionPropertyAllNonZero<Xs...>::value;
 };
 
 inline constexpr size_t FunctionPropertyDecimalBase = 10;
@@ -71,21 +71,21 @@ struct FunctionPropertySizeListToStrHelper<
           FunctionPropertyCharList<ParsedChars..., Chars..., ','>> {};
 
 template <size_t... Values, char... ParsedChars>
-struct FunctionPropertySizeListToStrHelper<FunctionPropertySizeList<0, Values...>,
-                                           FunctionPropertyCharList<ParsedChars...>>
+struct FunctionPropertySizeListToStrHelper<
+    FunctionPropertySizeList<0, Values...>,
+    FunctionPropertyCharList<ParsedChars...>>
     : FunctionPropertySizeListToStrHelper<
           FunctionPropertySizeList<Values...>,
           FunctionPropertyCharList<ParsedChars..., '0', ','>> {};
 
 template <char... ParsedChars, char... Chars>
-struct FunctionPropertySizeListToStrHelper<FunctionPropertySizeList<0>,
-                                           FunctionPropertyCharList<ParsedChars...>,
-                                           Chars...>
-    : FunctionPropertyCharsToStr<ParsedChars..., Chars...> {};
+struct FunctionPropertySizeListToStrHelper<
+    FunctionPropertySizeList<0>, FunctionPropertyCharList<ParsedChars...>,
+    Chars...> : FunctionPropertyCharsToStr<ParsedChars..., Chars...> {};
 
 template <char... ParsedChars>
-struct FunctionPropertySizeListToStrHelper<FunctionPropertySizeList<0>,
-                                           FunctionPropertyCharList<ParsedChars...>>
+struct FunctionPropertySizeListToStrHelper<
+    FunctionPropertySizeList<0>, FunctionPropertyCharList<ParsedChars...>>
     : FunctionPropertyCharsToStr<ParsedChars..., '0'> {};
 
 template <>
diff --git a/sycl/test/extensions/properties/function_properties_split.cpp b/sycl/test/extensions/properties/function_properties_split.cpp
index c72d27b1c115d..e9891185d0725 100644
--- a/sycl/test/extensions/properties/function_properties_split.cpp
+++ b/sycl/test/extensions/properties/function_properties_split.cpp
@@ -11,10 +11,12 @@ int main() {
   static_assert(is_property_value<decltype(nd_range_kernel<1>)>::value);
   static_assert(is_property_value<decltype(single_task_kernel)>::value);
   static_assert(is_property_value<decltype(work_group_size<2, 3>)>::value);
-  static_assert(is_property_value<decltype(work_group_size_hint<4, 5, 6>)>::value);
+  static_assert(
+      is_property_value<decltype(work_group_size_hint<4, 5, 6>)>::value);
   static_assert(is_property_value<decltype(sub_group_size<7>)>::value);
   static_assert(is_property_value<decltype(max_work_group_size<8, 9>)>::value);
-  static_assert(is_property_value<decltype(max_linear_work_group_size<10>)>::value);
+  static_assert(
+      is_property_value<decltype(max_linear_work_group_size<10>)>::value);
 
   static_assert(work_group_size<2, 3>[0] == 2);
   static_assert(work_group_size<2, 3>[1] == 3);
@@ -27,8 +29,8 @@ int main() {
                                work_group_size_key>);
   static_assert(std::is_same_v<decltype(work_group_size_hint<4>)::key_t,
                                work_group_size_hint_key>);
-  static_assert(std::is_same_v<decltype(sub_group_size<7>)::key_t,
-                               sub_group_size_key>);
+  static_assert(
+      std::is_same_v<decltype(sub_group_size<7>)::key_t, sub_group_size_key>);
   static_assert(std::is_same_v<decltype(max_work_group_size<8>)::key_t,
                                max_work_group_size_key>);
   static_assert(std::is_same_v<decltype(max_linear_work_group_size<10>)::key_t,

From faa95e1849cc93b7bee1695b960fe1b8714aa380 Mon Sep 17 00:00:00 2001
From: y <konstantinos.parasyris@intel.com>
Date: Thu, 23 Apr 2026 09:21:13 -0700
Subject: [PATCH 04/11] Update the user-facing documentation to point to the
 top-level kernel property headers instead of the nested kernel_properties/*
 paths.

Keep the legacy kernel_properties/* headers as forwarding compatibility
shims, add smoke tests for both legacy include paths, and mark the
shims for deletion once support for the old paths is dropped.
---
 ..._ext_oneapi_free_function_kernels.asciidoc |  10 +-
 ...sycl_ext_oneapi_kernel_properties.asciidoc |  12 +-
 .../sycl/detail/kernel_launch_helper.hpp      |  49 +-
 sycl/include/sycl/detail/range_rounding.hpp   |   2 +-
 .../ext/intel/esimd/memory_properties.hpp     |   2 +-
 .../experimental/cache_control_properties.hpp |   2 +-
 .../experimental/grf_size_properties.hpp      |   2 +-
 .../oneapi/device_global/device_global.hpp    |   2 +-
 .../annotated_ptr/annotated_ptr.hpp           |   2 +-
 .../annotated_ptr_properties.hpp              |   2 +-
 .../experimental/cluster_group_prop.hpp       |   2 +-
 .../properties.hpp                            |   2 +-
 .../oneapi/experimental/enqueue_functions.hpp |   2 +-
 .../ext/oneapi/experimental/graph/dynamic.hpp |   2 +-
 .../experimental/group_helpers_sorters.hpp    |   2 +-
 .../oneapi/experimental/group_load_store.hpp  |   2 +-
 .../sycl/ext/oneapi/experimental/prefetch.hpp |   2 +-
 .../experimental/syclbin_kernel_bundle.hpp    |   2 +-
 .../experimental/syclbin_properties.hpp       |   2 +-
 .../experimental/use_root_sync_prop.hpp       |   2 +-
 .../oneapi/experimental/virtual_functions.hpp |   2 +-
 .../oneapi/experimental/work_group_memory.hpp |   2 +-
 .../free_function_kernel_properties.hpp       | 389 ++++++++++++++++
 .../sycl/ext/oneapi/kernel_properties.hpp     | 184 ++++++++
 .../kernel_properties/function_properties.hpp | 398 +---------------
 .../oneapi/kernel_properties/properties.hpp   | 233 +---------
 sycl/include/sycl/ext/oneapi/properties.hpp   | 421 +++++++++++++++++
 .../sycl/ext/oneapi/properties/properties.hpp | 428 +-----------------
 .../ext/oneapi/work_group_scratch_memory.hpp  |   2 +-
 sycl/include/sycl/handler.hpp                 |   4 +-
 sycl/include/sycl/kernel_bundle.hpp           |   2 +-
 sycl/include/sycl/queue.hpp                   |   2 +-
 sycl/include/sycl/sycl.hpp                    |   4 +-
 .../free_function_kernels.hpp                 |   2 +-
 .../KernelCompiler/auto_pch_compile_error.cpp |   2 +-
 .../test-e2e/KernelCompiler/auto_pch_time.cpp |   2 +-
 .../conflicting_auto_pch_opts.cpp             |   2 +-
 .../KernelCompiler/empty_preamble.cpp         |   2 +-
 .../KernelCompiler/multi_threaded_rtc.cpp     |   2 +-
 .../multiple_auto_pch_includes.cpp            |   2 +-
 .../persistent_auto_pch_cache_collision.cpp   |   2 +-
 .../persistent_auto_pch_read_error.cpp        |   2 +-
 .../persistent_auto_pch_stress_deletion.cpp   |   2 +-
 .../preamble_define_before_include.cpp        |   2 +-
 .../KernelCompiler/preamble_if_stack.cpp      |   4 +-
 .../KernelCompiler/auto-pch.cpp               |   2 +-
 .../annotated_usm/invalid_usm_kind.cpp        |   2 +-
 .../properties/final_header_include_both.cpp  |  18 +
 .../properties/function_properties_split.cpp  |   2 +-
 .../kernel_function_properties_compat.cpp     |  20 +
 .../properties/kernel_properties_compat.cpp   |  20 +
 .../properties/properties_ctor_negative.cpp   |  12 +-
 .../properties_kernel_cache_config.cpp        |   2 +-
 .../properties/properties_kernel_negative.cpp | 160 +++----
 .../include_deps/sycl_detail_core.hpp.cpp     |   6 +-
 .../sycl_khr_includes_handler.hpp.cpp         |   6 +-
 .../sycl_khr_includes_interop_handle.hpp.cpp  |   2 +-
 .../sycl_khr_includes_kernel_bundle.hpp.cpp   |   6 +-
 .../sycl_khr_includes_queue.hpp.cpp           |   6 +-
 .../sycl_khr_includes_reduction.hpp.cpp       |   6 +-
 .../sycl_khr_includes_stream.hpp.cpp          |   6 +-
 .../sycl_khr_includes_usm.hpp.cpp             |   6 +-
 62 files changed, 1272 insertions(+), 1212 deletions(-)
 create mode 100644 sycl/include/sycl/ext/oneapi/free_function_kernel_properties.hpp
 create mode 100644 sycl/include/sycl/ext/oneapi/kernel_properties.hpp
 create mode 100644 sycl/include/sycl/ext/oneapi/properties.hpp
 create mode 100644 sycl/test/extensions/properties/final_header_include_both.cpp
 create mode 100644 sycl/test/extensions/properties/kernel_function_properties_compat.cpp
 create mode 100644 sycl/test/extensions/properties/kernel_properties_compat.cpp

diff --git a/sycl/doc/extensions/experimental/sycl_ext_oneapi_free_function_kernels.asciidoc b/sycl/doc/extensions/experimental/sycl_ext_oneapi_free_function_kernels.asciidoc
index d33b59a859229..4c972bec21738 100644
--- a/sycl/doc/extensions/experimental/sycl_ext_oneapi_free_function_kernels.asciidoc
+++ b/sycl/doc/extensions/experimental/sycl_ext_oneapi_free_function_kernels.asciidoc
@@ -117,7 +117,7 @@ supports.
 In the {dpcpp} implementation, applications that use this extension have a
 choice of headers depending on which properties they need:
 
-* `#include <sycl/ext/oneapi/kernel_properties/function_properties.hpp>` is
+* `#include <sycl/ext/oneapi/free_function_kernel_properties.hpp>` is
   sufficient for `SYCL_EXT_ONEAPI_FUNCTION_PROPERTY`,
   `nd_range_kernel<Dims>`, `single_task_kernel`, and the standalone
   compile-time kernel properties that may be applied directly to a free
@@ -125,7 +125,7 @@ choice of headers depending on which properties they need:
   `work_group_size_hint`, `sub_group_size`, `max_work_group_size`, and
   `max_linear_work_group_size`.
 
-* `#include <sycl/ext/oneapi/kernel_properties/properties.hpp>` provides the
+* `#include <sycl/ext/oneapi/kernel_properties.hpp>` provides the
   full kernel properties interface, including property lists such as
   `properties{...}` and embedded kernel properties via `properties_tag`.
 
@@ -135,7 +135,7 @@ the free-function annotation path.
 
 Code that forms property lists such as `properties{...}`, uses
 `properties_tag`, or depends on the umbrella property's property-list conflict
-checks should include `kernel_properties/properties.hpp`.
+checks should include `sycl/ext/oneapi/kernel_properties.hpp`.
 
 === Defining a free function kernel
 
@@ -829,8 +829,8 @@ sycl_ext_oneapi_kernel_properties] by applying the properties to the function
 declaration as illustrated below.
 
 In the {dpcpp} implementation, code that defines free-function kernels may
-include `function_properties.hpp` instead of the full
-`kernel_properties/properties.hpp` header when it only needs the
+include `sycl/ext/oneapi/free_function_kernel_properties.hpp` instead of the
+full `sycl/ext/oneapi/kernel_properties.hpp` header when it only needs the
 free-function annotation path. Applications that use property-list semantics,
 including `properties{...}`, `properties_tag`, or the associated
 property-list conflict checks, should include the umbrella header.
diff --git a/sycl/doc/extensions/experimental/sycl_ext_oneapi_kernel_properties.asciidoc b/sycl/doc/extensions/experimental/sycl_ext_oneapi_kernel_properties.asciidoc
index 52fc1ea1d07a6..4b40180c4180e 100644
--- a/sycl/doc/extensions/experimental/sycl_ext_oneapi_kernel_properties.asciidoc
+++ b/sycl/doc/extensions/experimental/sycl_ext_oneapi_kernel_properties.asciidoc
@@ -120,7 +120,7 @@ supports.
 In the {dpcpp} implementation, the full API described in this extension is
 provided by:
 
-* `#include <sycl/ext/oneapi/kernel_properties/properties.hpp>`
+* `#include <sycl/ext/oneapi/kernel_properties.hpp>`
 
 This umbrella header should be used when code needs property lists such as
 `properties{...}`, embedded kernel properties via `properties_tag`, or any of
@@ -129,7 +129,7 @@ the non-launch kernel properties described in this extension.
 The implementation also provides lighter-weight headers for code that only
 needs free-function annotations:
 
-* `#include <sycl/ext/oneapi/kernel_properties/function_properties.hpp>` for
+* `#include <sycl/ext/oneapi/free_function_kernel_properties.hpp>` for
   `nd_range_kernel<Dims>`, `single_task_kernel`,
   `SYCL_EXT_ONEAPI_FUNCTION_PROPERTY`, and the standalone compile-time kernel
   properties that may be applied directly to a free function declaration, such
@@ -139,10 +139,10 @@ needs free-function annotations:
 These lighter-weight headers are primarily intended for code paths where
 reduced compile time is a high priority and the application only needs
 function-level annotations.
-The `function_properties.hpp` header is intended for the free-function kernel
-definition path. Code that forms property lists, uses `properties_tag`, or
-depends on the umbrella property's property-list conflict checks should include
-`kernel_properties/properties.hpp`.
+The `sycl/ext/oneapi/free_function_kernel_properties.hpp` header is intended
+for the free-function kernel definition path. Code that forms property lists,
+uses `properties_tag`, or depends on the umbrella property's property-list
+conflict checks should include `sycl/ext/oneapi/kernel_properties.hpp`.
 
 === Kernel Properties
 
diff --git a/sycl/include/sycl/detail/kernel_launch_helper.hpp b/sycl/include/sycl/detail/kernel_launch_helper.hpp
index 909f6f2f49ae8..3aff73e58130d 100644
--- a/sycl/include/sycl/detail/kernel_launch_helper.hpp
+++ b/sycl/include/sycl/detail/kernel_launch_helper.hpp
@@ -19,7 +19,7 @@
 #include <sycl/ext/oneapi/experimental/graph.hpp>
 #include <sycl/ext/oneapi/experimental/use_root_sync_prop.hpp>
 #include <sycl/ext/oneapi/experimental/virtual_functions.hpp>
-#include <sycl/ext/oneapi/kernel_properties/properties.hpp>
+#include <sycl/ext/oneapi/kernel_properties.hpp>
 #include <sycl/ext/oneapi/work_group_scratch_memory.hpp>
 #include <sycl/kernel_handler.hpp>
 
@@ -361,6 +361,52 @@ using KernelPropertyHolderStructTy =
                 sycl::ext::oneapi::experimental::cuda::cluster_size_key<2>,
                 sycl::ext::oneapi::experimental::cuda::cluster_size_key<3>>;
 
+template <typename PropertiesT>
+constexpr void validateKernelProperties() {
+  using namespace sycl::ext::oneapi::experimental;
+
+  if constexpr (PropertiesT::template has_property<work_group_size_key>()) {
+    constexpr auto WGSize =
+        PropertiesT::template get_property<work_group_size_key>();
+
+    if constexpr (PropertiesT::template has_property<max_work_group_size_key>()) {
+      constexpr auto MaxWGSize =
+          PropertiesT::template get_property<max_work_group_size_key>();
+      constexpr auto WGDimensions = decltype(WGSize)::dimensions;
+      constexpr auto MaxWGDimensions = decltype(MaxWGSize)::dimensions;
+
+      static_assert(
+          WGDimensions == MaxWGDimensions,
+          "work_group_size and max_work_group_size dimensionality must match");
+      if constexpr (WGDimensions == MaxWGDimensions) {
+        static_assert(
+            WGDimensions < 1 || WGSize[0] <= MaxWGSize[0],
+            "work_group_size must not exceed max_work_group_size");
+        static_assert(
+            WGDimensions < 2 || WGSize[1] <= MaxWGSize[1],
+            "work_group_size must not exceed max_work_group_size");
+        static_assert(
+            WGDimensions < 3 || WGSize[2] <= MaxWGSize[2],
+            "work_group_size must not exceed max_work_group_size");
+      }
+    }
+
+    if constexpr (PropertiesT::template has_property<
+                      max_linear_work_group_size_key>()) {
+      constexpr auto Dimensions = decltype(WGSize)::dimensions;
+      constexpr auto LinearSize =
+          WGSize[0] * (Dimensions > 1 ? WGSize[1] : 1) *
+          (Dimensions > 2 ? WGSize[2] : 1);
+      constexpr auto MaxLinearWGSize =
+          PropertiesT::template get_property<max_linear_work_group_size_key>();
+
+      static_assert(
+          LinearSize < MaxLinearWGSize.value,
+          "work_group_size must not exceed max_linear_work_group_size");
+    }
+  }
+}
+
 /// Note: it is important that this function *does not* depend on kernel
 /// name or kernel type, because then it will be instantiated for every
 /// kernel, even though body of those instantiated functions could be almost
@@ -370,6 +416,7 @@ template <bool IsESIMDKernel = false, typename PropertiesT,
               ext::oneapi::experimental::is_property_list_v<PropertiesT>>>
 constexpr KernelPropertyHolderStructTy
 extractKernelProperties(PropertiesT Props) {
+  validateKernelProperties<PropertiesT>();
   static_assert(
       !PropertiesT::template has_property<
           sycl::ext::intel::experimental::fp_control_key>() ||
diff --git a/sycl/include/sycl/detail/range_rounding.hpp b/sycl/include/sycl/detail/range_rounding.hpp
index 37dfe4f603205..7dcc381b75fdb 100644
--- a/sycl/include/sycl/detail/range_rounding.hpp
+++ b/sycl/include/sycl/detail/range_rounding.hpp
@@ -13,7 +13,7 @@
 #include <sycl/detail/helpers.hpp>
 #include <sycl/detail/iostream_proxy.hpp>
 #include <sycl/device.hpp>
-#include <sycl/ext/oneapi/kernel_properties/properties.hpp>
+#include <sycl/ext/oneapi/kernel_properties.hpp>
 #include <sycl/id.hpp>
 #include <sycl/item.hpp>
 #include <sycl/kernel_handler.hpp>
diff --git a/sycl/include/sycl/ext/intel/esimd/memory_properties.hpp b/sycl/include/sycl/ext/intel/esimd/memory_properties.hpp
index f54a46b6fa922..9e87b226519ed 100644
--- a/sycl/include/sycl/ext/intel/esimd/memory_properties.hpp
+++ b/sycl/include/sycl/ext/intel/esimd/memory_properties.hpp
@@ -10,7 +10,7 @@
 
 #include <sycl/ext/intel/esimd/detail/defines_elementary.hpp>
 #include <sycl/ext/oneapi/experimental/common_annotated_properties/properties.hpp>
-#include <sycl/ext/oneapi/properties/properties.hpp>
+#include <sycl/ext/oneapi/properties.hpp>
 #include <sycl/ext/oneapi/properties/property_value.hpp>
 #include <utility>
 
diff --git a/sycl/include/sycl/ext/intel/experimental/cache_control_properties.hpp b/sycl/include/sycl/ext/intel/experimental/cache_control_properties.hpp
index ea8ec1020d54a..7f2e815afc4b7 100644
--- a/sycl/include/sycl/ext/intel/experimental/cache_control_properties.hpp
+++ b/sycl/include/sycl/ext/intel/experimental/cache_control_properties.hpp
@@ -10,7 +10,7 @@
 
 #include <sycl/ext/oneapi/experimental/common_annotated_properties/properties.hpp>
 #include <sycl/ext/oneapi/experimental/prefetch.hpp>
-#include <sycl/ext/oneapi/properties/properties.hpp>
+#include <sycl/ext/oneapi/properties.hpp>
 #include <sycl/ext/oneapi/properties/property.hpp>
 #include <sycl/ext/oneapi/properties/property_value.hpp>
 
diff --git a/sycl/include/sycl/ext/intel/experimental/grf_size_properties.hpp b/sycl/include/sycl/ext/intel/experimental/grf_size_properties.hpp
index f0edcb0c88706..ca5d2bddcb334 100644
--- a/sycl/include/sycl/ext/intel/experimental/grf_size_properties.hpp
+++ b/sycl/include/sycl/ext/intel/experimental/grf_size_properties.hpp
@@ -8,7 +8,7 @@
 
 #pragma once
 
-#include <sycl/ext/oneapi/properties/properties.hpp>
+#include <sycl/ext/oneapi/properties.hpp>
 #include <sycl/ext/oneapi/properties/property.hpp>
 #include <sycl/ext/oneapi/properties/property_value.hpp>
 
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 ecf8c970e2214..39b1a0921a678 100644
--- a/sycl/include/sycl/ext/oneapi/device_global/device_global.hpp
+++ b/sycl/include/sycl/ext/oneapi/device_global/device_global.hpp
@@ -11,7 +11,7 @@
 #include <sycl/access/access.hpp>                       // for address_space
 #include <sycl/exception.hpp>                           // for make_error_code
 #include <sycl/ext/oneapi/device_global/properties.hpp> // for device_image...
-#include <sycl/ext/oneapi/properties/properties.hpp>    // for properties_t
+#include <sycl/ext/oneapi/properties.hpp>               // for properties_t
 #include <sycl/multi_ptr.hpp>                           // for multi_ptr
 #include <sycl/pointers.hpp>                            // for decorated_gl...
 
diff --git a/sycl/include/sycl/ext/oneapi/experimental/annotated_ptr/annotated_ptr.hpp b/sycl/include/sycl/ext/oneapi/experimental/annotated_ptr/annotated_ptr.hpp
index bcec3d2aeced0..f009197c15cc4 100644
--- a/sycl/include/sycl/ext/oneapi/experimental/annotated_ptr/annotated_ptr.hpp
+++ b/sycl/include/sycl/ext/oneapi/experimental/annotated_ptr/annotated_ptr.hpp
@@ -13,7 +13,7 @@
 #include <sycl/ext/intel/experimental/cache_control_properties.hpp>
 #include <sycl/ext/oneapi/experimental/annotated_ptr/annotated_ptr_properties.hpp>
 #include <sycl/ext/oneapi/experimental/common_annotated_properties/properties.hpp>
-#include <sycl/ext/oneapi/properties/properties.hpp>
+#include <sycl/ext/oneapi/properties.hpp>
 #include <sycl/ext/oneapi/properties/property.hpp>
 #include <sycl/ext/oneapi/properties/property_value.hpp>
 #include <sycl/pointers.hpp>
diff --git a/sycl/include/sycl/ext/oneapi/experimental/annotated_ptr/annotated_ptr_properties.hpp b/sycl/include/sycl/ext/oneapi/experimental/annotated_ptr/annotated_ptr_properties.hpp
index 45a3fe63b6fda..5308d5c5a92d3 100644
--- a/sycl/include/sycl/ext/oneapi/experimental/annotated_ptr/annotated_ptr_properties.hpp
+++ b/sycl/include/sycl/ext/oneapi/experimental/annotated_ptr/annotated_ptr_properties.hpp
@@ -10,7 +10,7 @@
 #pragma once
 
 #include <sycl/ext/oneapi/experimental/common_annotated_properties/properties.hpp>
-#include <sycl/ext/oneapi/properties/properties.hpp> // for properties_t
+#include <sycl/ext/oneapi/properties.hpp> // for properties_t
 #include <sycl/usm/usm_enums.hpp>
 
 #include <type_traits> // for false_type, con...
diff --git a/sycl/include/sycl/ext/oneapi/experimental/cluster_group_prop.hpp b/sycl/include/sycl/ext/oneapi/experimental/cluster_group_prop.hpp
index 9e0d84afb660f..8bfe2ac56df15 100644
--- a/sycl/include/sycl/ext/oneapi/experimental/cluster_group_prop.hpp
+++ b/sycl/include/sycl/ext/oneapi/experimental/cluster_group_prop.hpp
@@ -8,7 +8,7 @@
 
 #pragma once
 
-#include <sycl/ext/oneapi/properties/properties.hpp>
+#include <sycl/ext/oneapi/properties.hpp>
 #include <sycl/range.hpp>
 
 namespace sycl {
diff --git a/sycl/include/sycl/ext/oneapi/experimental/common_annotated_properties/properties.hpp b/sycl/include/sycl/ext/oneapi/experimental/common_annotated_properties/properties.hpp
index 6b138ecd72669..cc3b3c981bfb0 100644
--- a/sycl/include/sycl/ext/oneapi/experimental/common_annotated_properties/properties.hpp
+++ b/sycl/include/sycl/ext/oneapi/experimental/common_annotated_properties/properties.hpp
@@ -8,7 +8,7 @@
 
 #pragma once
 
-#include <sycl/ext/oneapi/properties/properties.hpp> // for properties_t
+#include <sycl/ext/oneapi/properties.hpp> // for properties_t
 
 #include <type_traits> // for false_type, con...
 #include <utility>     // for declval
diff --git a/sycl/include/sycl/ext/oneapi/experimental/enqueue_functions.hpp b/sycl/include/sycl/ext/oneapi/experimental/enqueue_functions.hpp
index b364e94090360..4bcf9eb5647a4 100644
--- a/sycl/include/sycl/ext/oneapi/experimental/enqueue_functions.hpp
+++ b/sycl/include/sycl/ext/oneapi/experimental/enqueue_functions.hpp
@@ -15,7 +15,7 @@
 #include <sycl/ext/oneapi/experimental/enqueue_types.hpp>
 #include <sycl/ext/oneapi/experimental/free_function_traits.hpp>
 #include <sycl/ext/oneapi/experimental/graph.hpp>
-#include <sycl/ext/oneapi/properties/properties.hpp>
+#include <sycl/ext/oneapi/properties.hpp>
 #include <sycl/handler.hpp>
 #include <sycl/nd_range.hpp>
 #include <sycl/queue.hpp>
diff --git a/sycl/include/sycl/ext/oneapi/experimental/graph/dynamic.hpp b/sycl/include/sycl/ext/oneapi/experimental/graph/dynamic.hpp
index 9bfc71e378ec0..52eb0370c4c06 100644
--- a/sycl/include/sycl/ext/oneapi/experimental/graph/dynamic.hpp
+++ b/sycl/include/sycl/ext/oneapi/experimental/graph/dynamic.hpp
@@ -14,7 +14,7 @@
 #include <sycl/detail/export.hpp>      // for __SYCL_EXPORT
 #include <sycl/detail/kernel_desc.hpp> // for kernel_param_kind_t
 #include <sycl/ext/oneapi/experimental/work_group_memory.hpp> // for work_group_memory
-#include <sycl/ext/oneapi/properties/properties.hpp> // for empty_properties_t
+#include <sycl/ext/oneapi/properties.hpp> // for empty_properties_t
 
 #include <functional> // for function
 #include <memory>     // for shared_ptr
diff --git a/sycl/include/sycl/ext/oneapi/experimental/group_helpers_sorters.hpp b/sycl/include/sycl/ext/oneapi/experimental/group_helpers_sorters.hpp
index e6941dd4d19c0..2199663635a55 100644
--- a/sycl/include/sycl/ext/oneapi/experimental/group_helpers_sorters.hpp
+++ b/sycl/include/sycl/ext/oneapi/experimental/group_helpers_sorters.hpp
@@ -14,7 +14,7 @@
 #include <sycl/builtins.hpp>            // for min
 #include <sycl/exception.hpp>           // for sycl_category, exception
 #include <sycl/ext/oneapi/bfloat16.hpp> // for bfloat16
-#include <sycl/ext/oneapi/properties/properties.hpp>
+#include <sycl/ext/oneapi/properties.hpp>
 #include <sycl/memory_enums.hpp> // for memory_scope
 #include <sycl/range.hpp>        // for range
 #include <sycl/sycl_span.hpp>    // for span
diff --git a/sycl/include/sycl/ext/oneapi/experimental/group_load_store.hpp b/sycl/include/sycl/ext/oneapi/experimental/group_load_store.hpp
index 4bba7b980b5c1..b4cfe057b2a8d 100644
--- a/sycl/include/sycl/ext/oneapi/experimental/group_load_store.hpp
+++ b/sycl/include/sycl/ext/oneapi/experimental/group_load_store.hpp
@@ -13,7 +13,7 @@
 #include <sycl/detail/address_space_cast.hpp>
 #include <sycl/detail/helpers.hpp>
 #include <sycl/ext/oneapi/experimental/annotated_ptr/annotated_ptr.hpp>
-#include <sycl/ext/oneapi/properties/properties.hpp>
+#include <sycl/ext/oneapi/properties.hpp>
 #include <sycl/group_barrier.hpp>
 #include <sycl/sycl_span.hpp>
 
diff --git a/sycl/include/sycl/ext/oneapi/experimental/prefetch.hpp b/sycl/include/sycl/ext/oneapi/experimental/prefetch.hpp
index 8218a744eb1d4..8a6342970934f 100644
--- a/sycl/include/sycl/ext/oneapi/experimental/prefetch.hpp
+++ b/sycl/include/sycl/ext/oneapi/experimental/prefetch.hpp
@@ -10,7 +10,7 @@
 
 #include <sycl/__spirv/spirv_ops.hpp>
 #include <sycl/detail/address_space_cast.hpp>
-#include <sycl/ext/oneapi/properties/properties.hpp>
+#include <sycl/ext/oneapi/properties.hpp>
 #include <sycl/id.hpp>
 #include <sycl/vector.hpp>
 
diff --git a/sycl/include/sycl/ext/oneapi/experimental/syclbin_kernel_bundle.hpp b/sycl/include/sycl/ext/oneapi/experimental/syclbin_kernel_bundle.hpp
index 50f3c9e0841f1..f5f72d3c0da4b 100644
--- a/sycl/include/sycl/ext/oneapi/experimental/syclbin_kernel_bundle.hpp
+++ b/sycl/include/sycl/ext/oneapi/experimental/syclbin_kernel_bundle.hpp
@@ -9,7 +9,7 @@
 #pragma once
 
 #include <sycl/ext/oneapi/experimental/syclbin_properties.hpp>
-#include <sycl/ext/oneapi/properties/properties.hpp>
+#include <sycl/ext/oneapi/properties.hpp>
 #include <sycl/kernel_bundle.hpp>
 
 #include <fstream>
diff --git a/sycl/include/sycl/ext/oneapi/experimental/syclbin_properties.hpp b/sycl/include/sycl/ext/oneapi/experimental/syclbin_properties.hpp
index 3b74faeff9c8e..c6b1e78839df4 100644
--- a/sycl/include/sycl/ext/oneapi/experimental/syclbin_properties.hpp
+++ b/sycl/include/sycl/ext/oneapi/experimental/syclbin_properties.hpp
@@ -8,7 +8,7 @@
 
 #pragma once
 
-#include <sycl/ext/oneapi/properties/properties.hpp>
+#include <sycl/ext/oneapi/properties.hpp>
 #include <sycl/kernel_bundle.hpp>
 
 namespace sycl {
diff --git a/sycl/include/sycl/ext/oneapi/experimental/use_root_sync_prop.hpp b/sycl/include/sycl/ext/oneapi/experimental/use_root_sync_prop.hpp
index 3fbb4b9586d15..76424f2efb8a5 100644
--- a/sycl/include/sycl/ext/oneapi/experimental/use_root_sync_prop.hpp
+++ b/sycl/include/sycl/ext/oneapi/experimental/use_root_sync_prop.hpp
@@ -11,7 +11,7 @@
 
 #pragma once
 
-#include <sycl/ext/oneapi/properties/properties.hpp>
+#include <sycl/ext/oneapi/properties.hpp>
 
 namespace sycl {
 inline namespace _V1 {
diff --git a/sycl/include/sycl/ext/oneapi/experimental/virtual_functions.hpp b/sycl/include/sycl/ext/oneapi/experimental/virtual_functions.hpp
index 4ac20d852ec81..7fd51920f020b 100644
--- a/sycl/include/sycl/ext/oneapi/experimental/virtual_functions.hpp
+++ b/sycl/include/sycl/ext/oneapi/experimental/virtual_functions.hpp
@@ -1,6 +1,6 @@
 #pragma once
 
-#include <sycl/ext/oneapi/kernel_properties/function_properties.hpp>
+#include <sycl/ext/oneapi/free_function_kernel_properties.hpp>
 #include <sycl/ext/oneapi/properties/property.hpp>
 #include <sycl/ext/oneapi/properties/property_utils.hpp>
 #include <sycl/ext/oneapi/properties/property_value.hpp>
diff --git a/sycl/include/sycl/ext/oneapi/experimental/work_group_memory.hpp b/sycl/include/sycl/ext/oneapi/experimental/work_group_memory.hpp
index 099e2c92a2c4f..60089555575db 100644
--- a/sycl/include/sycl/ext/oneapi/experimental/work_group_memory.hpp
+++ b/sycl/include/sycl/ext/oneapi/experimental/work_group_memory.hpp
@@ -10,7 +10,7 @@
 #include <sycl/access/access.hpp>
 #include <sycl/detail/defines.hpp>
 #include <sycl/ext/oneapi/experimental/graph.hpp>
-#include <sycl/ext/oneapi/properties/properties.hpp>
+#include <sycl/ext/oneapi/properties.hpp>
 #include <sycl/multi_ptr.hpp>
 
 #include <cstddef>
diff --git a/sycl/include/sycl/ext/oneapi/free_function_kernel_properties.hpp b/sycl/include/sycl/ext/oneapi/free_function_kernel_properties.hpp
new file mode 100644
index 0000000000000..348478ac61272
--- /dev/null
+++ b/sycl/include/sycl/ext/oneapi/free_function_kernel_properties.hpp
@@ -0,0 +1,389 @@
+//==--- free_function_kernel_properties.hpp - SYCL free-function kernels --==//
+//
+// 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 <stddef.h>
+#include <stdint.h>
+#include <sycl/ext/oneapi/properties/property_value.hpp>
+
+#include <type_traits>
+
+namespace sycl {
+inline namespace _V1 {
+namespace ext::oneapi::experimental {
+namespace detail {
+
+template <typename T>
+using remove_cvref_t = std::remove_cv_t<std::remove_reference_t<T>>;
+
+template <typename PropertyT> struct FunctionPropertyMetaInfo;
+
+template <size_t... Xs> struct FunctionPropertyAllNonZero {
+	static constexpr bool value = true;
+};
+template <size_t X, size_t... Xs> struct FunctionPropertyAllNonZero<X, Xs...> {
+	static constexpr bool value =
+			X > 0 && FunctionPropertyAllNonZero<Xs...>::value;
+};
+
+inline constexpr size_t FunctionPropertyDecimalBase = 10;
+
+template <size_t... Sizes> struct FunctionPropertySizeList {};
+template <char... Chars> struct FunctionPropertyCharList {};
+
+template <char... Chars> struct FunctionPropertyCharsToStr {
+	static constexpr const char value[] = {Chars..., '\0'};
+};
+
+template <typename List, typename ParsedList, char... Chars>
+struct FunctionPropertySizeListToStrHelper;
+
+template <size_t Value, size_t... Values, char... ParsedChars, char... Chars>
+struct FunctionPropertySizeListToStrHelper<
+		FunctionPropertySizeList<Value, Values...>,
+		FunctionPropertyCharList<ParsedChars...>, Chars...>
+		: FunctionPropertySizeListToStrHelper<
+					FunctionPropertySizeList<Value / FunctionPropertyDecimalBase,
+																	 Values...>,
+					FunctionPropertyCharList<ParsedChars...>,
+					'0' + (Value % FunctionPropertyDecimalBase), Chars...> {};
+
+template <size_t... Values, char... ParsedChars, char... Chars>
+struct FunctionPropertySizeListToStrHelper<
+		FunctionPropertySizeList<0, Values...>,
+		FunctionPropertyCharList<ParsedChars...>, Chars...>
+		: FunctionPropertySizeListToStrHelper<
+					FunctionPropertySizeList<Values...>,
+					FunctionPropertyCharList<ParsedChars..., Chars..., ','>> {};
+
+template <size_t... Values, char... ParsedChars>
+struct FunctionPropertySizeListToStrHelper<
+		FunctionPropertySizeList<0, Values...>,
+		FunctionPropertyCharList<ParsedChars...>>
+		: FunctionPropertySizeListToStrHelper<
+					FunctionPropertySizeList<Values...>,
+					FunctionPropertyCharList<ParsedChars..., '0', ','>> {};
+
+template <char... ParsedChars, char... Chars>
+struct FunctionPropertySizeListToStrHelper<
+		FunctionPropertySizeList<0>, FunctionPropertyCharList<ParsedChars...>,
+		Chars...> : FunctionPropertyCharsToStr<ParsedChars..., Chars...> {};
+
+template <char... ParsedChars>
+struct FunctionPropertySizeListToStrHelper<
+		FunctionPropertySizeList<0>, FunctionPropertyCharList<ParsedChars...>>
+		: FunctionPropertyCharsToStr<ParsedChars..., '0'> {};
+
+template <>
+struct FunctionPropertySizeListToStrHelper<FunctionPropertySizeList<>,
+																					 FunctionPropertyCharList<>>
+		: FunctionPropertyCharsToStr<> {};
+
+template <size_t... Sizes>
+struct FunctionPropertySizeListToStr
+		: FunctionPropertySizeListToStrHelper<FunctionPropertySizeList<Sizes...>,
+																					FunctionPropertyCharList<>> {};
+
+} // namespace detail
+
+struct nd_range_kernel_key
+		: detail::compile_time_property_key<detail::PropKind::NDRangeKernel> {
+	template <int Dims>
+	using value_t =
+			property_value<nd_range_kernel_key, std::integral_constant<int, Dims>>;
+};
+
+struct single_task_kernel_key
+		: detail::compile_time_property_key<detail::PropKind::SingleTaskKernel> {
+	using value_t = property_value<single_task_kernel_key>;
+};
+
+template <int Dims>
+struct property_value<nd_range_kernel_key, std::integral_constant<int, Dims>>
+		: detail::property_base<property_value<nd_range_kernel_key,
+																					 std::integral_constant<int, Dims>>,
+														detail::PropKind::NDRangeKernel,
+														nd_range_kernel_key> {
+	static_assert(Dims >= 1 && Dims <= 3,
+								"nd_range_kernel must use dimension 1, 2, or 3.");
+
+	using value_t = int;
+	static constexpr int dimensions = Dims;
+};
+
+template <>
+struct property_value<single_task_kernel_key>
+		: detail::property_base<property_value<single_task_kernel_key>,
+														detail::PropKind::SingleTaskKernel,
+														single_task_kernel_key> {};
+
+template <int Dims>
+inline constexpr nd_range_kernel_key::value_t<Dims> nd_range_kernel;
+
+inline constexpr single_task_kernel_key::value_t single_task_kernel;
+
+struct work_group_size_key
+		: detail::compile_time_property_key<detail::PropKind::WorkGroupSize> {
+	template <size_t... Dims>
+	using value_t = property_value<work_group_size_key,
+																 std::integral_constant<size_t, Dims>...>;
+};
+
+struct work_group_size_hint_key
+		: detail::compile_time_property_key<detail::PropKind::WorkGroupSizeHint> {
+	template <size_t... Dims>
+	using value_t = property_value<work_group_size_hint_key,
+																 std::integral_constant<size_t, Dims>...>;
+};
+
+struct sub_group_size_key
+		: detail::compile_time_property_key<detail::PropKind::SubGroupSize> {
+	template <uint32_t Size>
+	using value_t = property_value<sub_group_size_key,
+																 std::integral_constant<uint32_t, Size>>;
+};
+
+struct max_work_group_size_key
+		: detail::compile_time_property_key<detail::PropKind::MaxWorkGroupSize> {
+	template <size_t... Dims>
+	using value_t = property_value<max_work_group_size_key,
+																 std::integral_constant<size_t, Dims>...>;
+};
+
+struct max_linear_work_group_size_key
+		: detail::compile_time_property_key<
+					detail::PropKind::MaxLinearWorkGroupSize> {
+	template <size_t Size>
+	using value_t = property_value<max_linear_work_group_size_key,
+																 std::integral_constant<size_t, Size>>;
+};
+
+template <size_t Dim0, size_t... Dims>
+struct property_value<work_group_size_key, std::integral_constant<size_t, Dim0>,
+											std::integral_constant<size_t, Dims>...>
+		: detail::property_base<
+					property_value<work_group_size_key,
+												 std::integral_constant<size_t, Dim0>,
+												 std::integral_constant<size_t, Dims>...>,
+					detail::PropKind::WorkGroupSize, work_group_size_key> {
+	static_assert(
+			sizeof...(Dims) + 1 <= 3,
+			"work_group_size property currently only supports up to three values.");
+	static_assert(detail::FunctionPropertyAllNonZero<Dim0, Dims...>::value,
+								"work_group_size property must only contain non-zero values.");
+
+	static constexpr size_t dimensions = sizeof...(Dims) + 1;
+
+	constexpr size_t operator[](int Dim) const {
+		constexpr size_t Values[] = {Dim0, Dims...};
+		return Values[Dim];
+	}
+};
+
+template <size_t Dim0, size_t... Dims>
+struct property_value<work_group_size_hint_key,
+											std::integral_constant<size_t, Dim0>,
+											std::integral_constant<size_t, Dims>...>
+		: detail::property_base<
+					property_value<work_group_size_hint_key,
+												 std::integral_constant<size_t, Dim0>,
+												 std::integral_constant<size_t, Dims>...>,
+					detail::PropKind::WorkGroupSizeHint, work_group_size_hint_key> {
+	static_assert(sizeof...(Dims) + 1 <= 3,
+								"work_group_size_hint property currently only supports up to "
+								"three values.");
+	static_assert(
+			detail::FunctionPropertyAllNonZero<Dim0, Dims...>::value,
+			"work_group_size_hint property must only contain non-zero values.");
+
+	constexpr size_t operator[](int Dim) const {
+		constexpr size_t Values[] = {Dim0, Dims...};
+		return Values[Dim];
+	}
+};
+
+template <uint32_t Size>
+struct property_value<sub_group_size_key,
+											std::integral_constant<uint32_t, Size>>
+		: detail::property_base<
+					property_value<sub_group_size_key,
+												 std::integral_constant<uint32_t, Size>>,
+					detail::PropKind::SubGroupSize, sub_group_size_key> {
+	static_assert(Size != 0,
+								"sub_group_size property must contain a non-zero value.");
+
+	using value_t = std::integral_constant<uint32_t, Size>;
+	static constexpr uint32_t value = Size;
+};
+
+template <size_t Dim0, size_t... Dims>
+struct property_value<max_work_group_size_key,
+											std::integral_constant<size_t, Dim0>,
+											std::integral_constant<size_t, Dims>...>
+		: detail::property_base<
+					property_value<max_work_group_size_key,
+												 std::integral_constant<size_t, Dim0>,
+												 std::integral_constant<size_t, Dims>...>,
+					detail::PropKind::MaxWorkGroupSize, max_work_group_size_key> {
+	static_assert(
+			sizeof...(Dims) + 1 <= 3,
+			"max_work_group_size currently only supports up to three values.");
+	static_assert(detail::FunctionPropertyAllNonZero<Dim0, Dims...>::value,
+								"max_work_group_size must only contain non-zero values.");
+
+	static constexpr size_t dimensions = sizeof...(Dims) + 1;
+
+	constexpr size_t operator[](int Dim) const {
+		constexpr size_t Values[] = {Dim0, Dims...};
+		return Values[Dim];
+	}
+};
+
+template <size_t Size>
+struct property_value<max_linear_work_group_size_key,
+											std::integral_constant<size_t, Size>>
+		: detail::property_base<
+					property_value<max_linear_work_group_size_key,
+												 std::integral_constant<size_t, Size>>,
+					detail::PropKind::MaxLinearWorkGroupSize,
+					max_linear_work_group_size_key> {
+	static_assert(Size != 0,
+								"max_linear_work_group_size must contain a non-zero value.");
+
+	using value_t = std::integral_constant<size_t, Size>;
+	static constexpr size_t value = Size;
+};
+
+template <size_t Dim0, size_t... Dims>
+inline constexpr work_group_size_key::value_t<Dim0, Dims...> work_group_size;
+
+template <size_t Dim0, size_t... Dims>
+inline constexpr work_group_size_hint_key::value_t<Dim0, Dims...>
+		work_group_size_hint;
+
+template <uint32_t Size>
+inline constexpr sub_group_size_key::value_t<Size> sub_group_size;
+
+template <size_t Dim0, size_t... Dims>
+inline constexpr max_work_group_size_key::value_t<Dim0, Dims...>
+		max_work_group_size;
+
+template <size_t Size>
+inline constexpr max_linear_work_group_size_key::value_t<Size>
+		max_linear_work_group_size;
+
+namespace detail {
+
+template <int Dims>
+struct FunctionPropertyMetaInfo<nd_range_kernel_key::value_t<Dims>> {
+	static constexpr const char *name = "sycl-nd-range-kernel";
+	static constexpr int value = Dims;
+};
+
+template <> struct FunctionPropertyMetaInfo<single_task_kernel_key::value_t> {
+	static constexpr const char *name = "sycl-single-task-kernel";
+	static constexpr int value = 0;
+};
+
+template <size_t... Dims>
+struct HasCompileTimeEffect<work_group_size_key::value_t<Dims...>>
+		: std::true_type {};
+template <size_t... Dims>
+struct HasCompileTimeEffect<work_group_size_hint_key::value_t<Dims...>>
+		: std::true_type {};
+template <uint32_t Size>
+struct HasCompileTimeEffect<sub_group_size_key::value_t<Size>>
+		: std::true_type {};
+template <size_t... Dims>
+struct HasCompileTimeEffect<max_work_group_size_key::value_t<Dims...>>
+		: std::true_type {};
+template <size_t Size>
+struct HasCompileTimeEffect<max_linear_work_group_size_key::value_t<Size>>
+		: std::true_type {};
+
+template <size_t Dim0, size_t... Dims>
+struct PropertyMetaInfo<work_group_size_key::value_t<Dim0, Dims...>> {
+	static constexpr const char *name = "sycl-work-group-size";
+	static constexpr const char *value =
+			FunctionPropertySizeListToStr<Dim0, Dims...>::value;
+};
+template <size_t Dim0, size_t... Dims>
+struct FunctionPropertyMetaInfo<work_group_size_key::value_t<Dim0, Dims...>> {
+	static constexpr const char *name = "sycl-work-group-size";
+	static constexpr const char *value =
+			FunctionPropertySizeListToStr<Dim0, Dims...>::value;
+};
+
+template <size_t Dim0, size_t... Dims>
+struct PropertyMetaInfo<work_group_size_hint_key::value_t<Dim0, Dims...>> {
+	static constexpr const char *name = "sycl-work-group-size-hint";
+	static constexpr const char *value =
+			FunctionPropertySizeListToStr<Dim0, Dims...>::value;
+};
+template <size_t Dim0, size_t... Dims>
+struct FunctionPropertyMetaInfo<
+		work_group_size_hint_key::value_t<Dim0, Dims...>> {
+	static constexpr const char *name = "sycl-work-group-size-hint";
+	static constexpr const char *value =
+			FunctionPropertySizeListToStr<Dim0, Dims...>::value;
+};
+
+template <uint32_t Size>
+struct PropertyMetaInfo<sub_group_size_key::value_t<Size>> {
+	static constexpr const char *name = "sycl-sub-group-size";
+	static constexpr uint32_t value = Size;
+};
+template <uint32_t Size>
+struct FunctionPropertyMetaInfo<sub_group_size_key::value_t<Size>> {
+	static constexpr const char *name = "sycl-sub-group-size";
+	static constexpr uint32_t value = Size;
+};
+
+template <size_t Dim0, size_t... Dims>
+struct PropertyMetaInfo<max_work_group_size_key::value_t<Dim0, Dims...>> {
+	static constexpr const char *name = "sycl-max-work-group-size";
+	static constexpr const char *value =
+			FunctionPropertySizeListToStr<Dim0, Dims...>::value;
+};
+template <size_t Dim0, size_t... Dims>
+struct FunctionPropertyMetaInfo<
+		max_work_group_size_key::value_t<Dim0, Dims...>> {
+	static constexpr const char *name = "sycl-max-work-group-size";
+	static constexpr const char *value =
+			FunctionPropertySizeListToStr<Dim0, Dims...>::value;
+};
+
+template <size_t Size>
+struct PropertyMetaInfo<max_linear_work_group_size_key::value_t<Size>> {
+	static constexpr const char *name = "sycl-max-linear-work-group-size";
+	static constexpr size_t value = Size;
+};
+template <size_t Size>
+struct FunctionPropertyMetaInfo<max_linear_work_group_size_key::value_t<Size>> {
+	static constexpr const char *name = "sycl-max-linear-work-group-size";
+	static constexpr size_t value = Size;
+};
+
+} // namespace detail
+} // namespace ext::oneapi::experimental
+} // namespace _V1
+} // namespace sycl
+
+#ifdef __SYCL_DEVICE_ONLY__
+#define SYCL_EXT_ONEAPI_FUNCTION_PROPERTY(PROP)                                \
+	[[__sycl_detail__::add_ir_attributes_function(                               \
+			sycl::ext::oneapi::experimental::detail::FunctionPropertyMetaInfo<       \
+					sycl::ext::oneapi::experimental::detail::remove_cvref_t<             \
+							decltype(PROP)>>::name,                                          \
+			sycl::ext::oneapi::experimental::detail::FunctionPropertyMetaInfo<       \
+					sycl::ext::oneapi::experimental::detail::remove_cvref_t<             \
+							decltype(PROP)>>::value)]]
+#else
+#define SYCL_EXT_ONEAPI_FUNCTION_PROPERTY(PROP)
+#endif
\ No newline at end of file
diff --git a/sycl/include/sycl/ext/oneapi/kernel_properties.hpp b/sycl/include/sycl/ext/oneapi/kernel_properties.hpp
new file mode 100644
index 0000000000000..06a01cb51288f
--- /dev/null
+++ b/sycl/include/sycl/ext/oneapi/kernel_properties.hpp
@@ -0,0 +1,184 @@
+//==----------- kernel_properties.hpp - SYCL kernel properties ------------==//
+//
+// 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 <array>
+#include <stddef.h>
+#include <stdint.h>
+#include <sycl/aspects.hpp>
+#include <sycl/ext/oneapi/experimental/forward_progress.hpp>
+#include <sycl/ext/oneapi/free_function_kernel_properties.hpp>
+#include <sycl/ext/oneapi/properties.hpp>
+#include <type_traits>
+#include <utility>
+
+namespace sycl {
+inline namespace _V1 {
+namespace ext::oneapi::experimental {
+
+struct properties_tag {};
+
+struct device_has_key
+		: detail::compile_time_property_key<detail::PropKind::DeviceHas> {
+	template <aspect... Aspects>
+	using value_t = property_value<device_has_key,
+																 std::integral_constant<aspect, Aspects>...>;
+};
+
+template <aspect... Aspects>
+struct property_value<device_has_key,
+											std::integral_constant<aspect, Aspects>...>
+		: detail::property_base<
+					property_value<device_has_key,
+												 std::integral_constant<aspect, Aspects>...>,
+					detail::PropKind::DeviceHas, device_has_key> {
+	static constexpr std::array<aspect, sizeof...(Aspects)> value{Aspects...};
+};
+
+template <aspect... Aspects>
+inline constexpr device_has_key::value_t<Aspects...> device_has;
+
+struct work_group_progress_key
+		: detail::compile_time_property_key<detail::PropKind::WorkGroupProgress> {
+	template <forward_progress_guarantee Guarantee,
+						execution_scope CoordinationScope>
+	using value_t = property_value<
+			work_group_progress_key,
+			std::integral_constant<forward_progress_guarantee, Guarantee>,
+			std::integral_constant<execution_scope, CoordinationScope>>;
+};
+
+struct sub_group_progress_key
+		: detail::compile_time_property_key<detail::PropKind::SubGroupProgress> {
+	template <forward_progress_guarantee Guarantee,
+						execution_scope CoordinationScope>
+	using value_t = property_value<
+			sub_group_progress_key,
+			std::integral_constant<forward_progress_guarantee, Guarantee>,
+			std::integral_constant<execution_scope, CoordinationScope>>;
+};
+
+struct work_item_progress_key
+		: detail::compile_time_property_key<detail::PropKind::WorkItemProgress> {
+	template <forward_progress_guarantee Guarantee,
+						execution_scope CoordinationScope>
+	using value_t = property_value<
+			work_item_progress_key,
+			std::integral_constant<forward_progress_guarantee, Guarantee>,
+			std::integral_constant<execution_scope, CoordinationScope>>;
+};
+
+template <forward_progress_guarantee Guarantee,
+					execution_scope CoordinationScope>
+struct property_value<
+		work_group_progress_key,
+		std::integral_constant<forward_progress_guarantee, Guarantee>,
+		std::integral_constant<execution_scope, CoordinationScope>>
+		: detail::property_base<
+					property_value<
+							work_group_progress_key,
+							std::integral_constant<forward_progress_guarantee, Guarantee>,
+							std::integral_constant<execution_scope, CoordinationScope>>,
+					detail::PropKind::WorkGroupProgress, work_group_progress_key> {
+	static constexpr forward_progress_guarantee guarantee = Guarantee;
+	static constexpr execution_scope coordinationScope = CoordinationScope;
+};
+
+template <forward_progress_guarantee Guarantee,
+					execution_scope CoordinationScope>
+struct property_value<
+		sub_group_progress_key,
+		std::integral_constant<forward_progress_guarantee, Guarantee>,
+		std::integral_constant<execution_scope, CoordinationScope>>
+		: detail::property_base<
+					property_value<
+							sub_group_progress_key,
+							std::integral_constant<forward_progress_guarantee, Guarantee>,
+							std::integral_constant<execution_scope, CoordinationScope>>,
+					detail::PropKind::SubGroupProgress, sub_group_progress_key> {
+	static constexpr forward_progress_guarantee guarantee = Guarantee;
+	static constexpr execution_scope coordinationScope = CoordinationScope;
+};
+
+template <forward_progress_guarantee Guarantee,
+					execution_scope CoordinationScope>
+struct property_value<
+		work_item_progress_key,
+		std::integral_constant<forward_progress_guarantee, Guarantee>,
+		std::integral_constant<execution_scope, CoordinationScope>>
+		: detail::property_base<
+					property_value<
+							work_item_progress_key,
+							std::integral_constant<forward_progress_guarantee, Guarantee>,
+							std::integral_constant<execution_scope, CoordinationScope>>,
+					detail::PropKind::WorkItemProgress, work_item_progress_key> {
+	static constexpr forward_progress_guarantee guarantee = Guarantee;
+	static constexpr execution_scope coordinationScope = CoordinationScope;
+};
+
+template <forward_progress_guarantee Guarantee,
+					execution_scope CoordinationScope>
+inline constexpr work_group_progress_key::value_t<Guarantee, CoordinationScope>
+		work_group_progress;
+
+template <forward_progress_guarantee Guarantee,
+					execution_scope CoordinationScope>
+inline constexpr sub_group_progress_key::value_t<Guarantee, CoordinationScope>
+		sub_group_progress;
+
+template <forward_progress_guarantee Guarantee,
+					execution_scope CoordinationScope>
+inline constexpr work_item_progress_key::value_t<Guarantee, CoordinationScope>
+		work_item_progress;
+
+namespace detail {
+template <sycl::aspect... Aspects>
+struct HasCompileTimeEffect<device_has_key::value_t<Aspects...>>
+		: std::true_type {};
+template <aspect... Aspects>
+struct PropertyMetaInfo<device_has_key::value_t<Aspects...>> {
+	static constexpr const char *name = "sycl-device-has";
+	static constexpr const char *value =
+			SizeListToStr<static_cast<size_t>(Aspects)...>::value;
+};
+template <aspect... Aspects>
+struct FunctionPropertyMetaInfo<device_has_key::value_t<Aspects...>> {
+	static constexpr const char *name = "sycl-device-has";
+	static constexpr const char *value =
+			SizeListToStr<static_cast<size_t>(Aspects)...>::value;
+};
+
+template <typename T, typename = void>
+struct HasKernelPropertiesGetMethod : std::false_type {};
+
+template <typename T>
+struct HasKernelPropertiesGetMethod<T,
+																		std::void_t<decltype(std::declval<T>().get(
+																				std::declval<properties_tag>()))>>
+		: std::true_type {
+	using properties_t =
+			decltype(std::declval<T>().get(std::declval<properties_tag>()));
+};
+
+template <typename... RestT>
+auto RetrieveGetMethodPropertiesOrEmpty(RestT &&...Rest) {
+	auto Identity = [](const auto &x) -> decltype(auto) { return x; };
+	const auto &KernelObj = (Identity(Rest), ...);
+	if constexpr (ext::oneapi::experimental::detail::HasKernelPropertiesGetMethod<
+										decltype(KernelObj)>::value) {
+		return KernelObj.get(ext::oneapi::experimental::properties_tag{});
+	} else {
+		return ext::oneapi::experimental::empty_properties_t{};
+	}
+}
+
+} // namespace detail
+} // namespace ext::oneapi::experimental
+} // namespace _V1
+} // namespace sycl
\ No newline at end of file
diff --git a/sycl/include/sycl/ext/oneapi/kernel_properties/function_properties.hpp b/sycl/include/sycl/ext/oneapi/kernel_properties/function_properties.hpp
index bd2d7b8c41172..de7babba8c99f 100644
--- a/sycl/include/sycl/ext/oneapi/kernel_properties/function_properties.hpp
+++ b/sycl/include/sycl/ext/oneapi/kernel_properties/function_properties.hpp
@@ -1,4 +1,4 @@
-//==--- function_properties.hpp - SYCL standalone function properties -----==//
+//==--- function_properties.hpp - compatibility forwarding header ---------==//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
@@ -8,396 +8,6 @@
 
 #pragma once
 
-// This header is the lightweight split entry point for free-function kernel
-// annotations and standalone compile-time kernel properties that do not need
-// the umbrella property's property-list machinery. Keep these public
-// property_value definitions here so standalone users and umbrella users
-// observe the same decltype(...) while avoiding the heavier machinery on this
-// path.
-
-#include <stddef.h>
-#include <stdint.h>
-#include <sycl/ext/oneapi/properties/property_value.hpp>
-
-#include <type_traits>
-
-namespace sycl {
-inline namespace _V1 {
-namespace ext::oneapi::experimental {
-namespace detail {
-
-template <typename T>
-using remove_cvref_t = std::remove_cv_t<std::remove_reference_t<T>>;
-
-template <typename PropertyT> struct FunctionPropertyMetaInfo;
-template <typename PropKey, typename Properties> struct ConflictingProperties;
-
-template <size_t... Xs> struct FunctionPropertyAllNonZero {
-  static constexpr bool value = true;
-};
-template <size_t X, size_t... Xs> struct FunctionPropertyAllNonZero<X, Xs...> {
-  static constexpr bool value =
-      X > 0 && FunctionPropertyAllNonZero<Xs...>::value;
-};
-
-inline constexpr size_t FunctionPropertyDecimalBase = 10;
-
-template <size_t... Sizes> struct FunctionPropertySizeList {};
-template <char... Chars> struct FunctionPropertyCharList {};
-
-template <char... Chars> struct FunctionPropertyCharsToStr {
-  static constexpr const char value[] = {Chars..., '\0'};
-};
-
-template <typename List, typename ParsedList, char... Chars>
-struct FunctionPropertySizeListToStrHelper;
-
-template <size_t Value, size_t... Values, char... ParsedChars, char... Chars>
-struct FunctionPropertySizeListToStrHelper<
-    FunctionPropertySizeList<Value, Values...>,
-    FunctionPropertyCharList<ParsedChars...>, Chars...>
-    : FunctionPropertySizeListToStrHelper<
-          FunctionPropertySizeList<Value / FunctionPropertyDecimalBase,
-                                   Values...>,
-          FunctionPropertyCharList<ParsedChars...>,
-          '0' + (Value % FunctionPropertyDecimalBase), Chars...> {};
-
-template <size_t... Values, char... ParsedChars, char... Chars>
-struct FunctionPropertySizeListToStrHelper<
-    FunctionPropertySizeList<0, Values...>,
-    FunctionPropertyCharList<ParsedChars...>, Chars...>
-    : FunctionPropertySizeListToStrHelper<
-          FunctionPropertySizeList<Values...>,
-          FunctionPropertyCharList<ParsedChars..., Chars..., ','>> {};
-
-template <size_t... Values, char... ParsedChars>
-struct FunctionPropertySizeListToStrHelper<
-    FunctionPropertySizeList<0, Values...>,
-    FunctionPropertyCharList<ParsedChars...>>
-    : FunctionPropertySizeListToStrHelper<
-          FunctionPropertySizeList<Values...>,
-          FunctionPropertyCharList<ParsedChars..., '0', ','>> {};
-
-template <char... ParsedChars, char... Chars>
-struct FunctionPropertySizeListToStrHelper<
-    FunctionPropertySizeList<0>, FunctionPropertyCharList<ParsedChars...>,
-    Chars...> : FunctionPropertyCharsToStr<ParsedChars..., Chars...> {};
-
-template <char... ParsedChars>
-struct FunctionPropertySizeListToStrHelper<
-    FunctionPropertySizeList<0>, FunctionPropertyCharList<ParsedChars...>>
-    : FunctionPropertyCharsToStr<ParsedChars..., '0'> {};
-
-template <>
-struct FunctionPropertySizeListToStrHelper<FunctionPropertySizeList<>,
-                                           FunctionPropertyCharList<>>
-    : FunctionPropertyCharsToStr<> {};
-
-template <size_t... Sizes>
-struct FunctionPropertySizeListToStr
-    : FunctionPropertySizeListToStrHelper<FunctionPropertySizeList<Sizes...>,
-                                          FunctionPropertyCharList<>> {};
-
-} // namespace detail
-
-struct nd_range_kernel_key
-    : detail::compile_time_property_key<detail::PropKind::NDRangeKernel> {
-  template <int Dims>
-  using value_t =
-      property_value<nd_range_kernel_key, std::integral_constant<int, Dims>>;
-};
-
-struct single_task_kernel_key
-    : detail::compile_time_property_key<detail::PropKind::SingleTaskKernel> {
-  using value_t = property_value<single_task_kernel_key>;
-};
-
-template <int Dims>
-struct property_value<nd_range_kernel_key, std::integral_constant<int, Dims>>
-    : detail::property_base<property_value<nd_range_kernel_key,
-                                           std::integral_constant<int, Dims>>,
-                            detail::PropKind::NDRangeKernel,
-                            nd_range_kernel_key> {
-  static_assert(Dims >= 1 && Dims <= 3,
-                "nd_range_kernel must use dimension 1, 2, or 3.");
-
-  using value_t = int;
-  static constexpr int dimensions = Dims;
-};
-
-template <>
-struct property_value<single_task_kernel_key>
-    : detail::property_base<property_value<single_task_kernel_key>,
-                            detail::PropKind::SingleTaskKernel,
-                            single_task_kernel_key> {};
-
-template <int Dims>
-inline constexpr nd_range_kernel_key::value_t<Dims> nd_range_kernel;
-
-inline constexpr single_task_kernel_key::value_t single_task_kernel;
-
-struct work_group_size_key
-    : detail::compile_time_property_key<detail::PropKind::WorkGroupSize> {
-  template <size_t... Dims>
-  using value_t = property_value<work_group_size_key,
-                                 std::integral_constant<size_t, Dims>...>;
-};
-
-struct work_group_size_hint_key
-    : detail::compile_time_property_key<detail::PropKind::WorkGroupSizeHint> {
-  template <size_t... Dims>
-  using value_t = property_value<work_group_size_hint_key,
-                                 std::integral_constant<size_t, Dims>...>;
-};
-
-struct sub_group_size_key
-    : detail::compile_time_property_key<detail::PropKind::SubGroupSize> {
-  template <uint32_t Size>
-  using value_t = property_value<sub_group_size_key,
-                                 std::integral_constant<uint32_t, Size>>;
-};
-
-struct max_work_group_size_key
-    : detail::compile_time_property_key<detail::PropKind::MaxWorkGroupSize> {
-  template <size_t... Dims>
-  using value_t = property_value<max_work_group_size_key,
-                                 std::integral_constant<size_t, Dims>...>;
-};
-
-struct max_linear_work_group_size_key
-    : detail::compile_time_property_key<
-          detail::PropKind::MaxLinearWorkGroupSize> {
-  template <size_t Size>
-  using value_t = property_value<max_linear_work_group_size_key,
-                                 std::integral_constant<size_t, Size>>;
-};
-
-template <size_t Dim0, size_t... Dims>
-struct property_value<work_group_size_key, std::integral_constant<size_t, Dim0>,
-                      std::integral_constant<size_t, Dims>...>
-    : detail::property_base<
-          property_value<work_group_size_key,
-                         std::integral_constant<size_t, Dim0>,
-                         std::integral_constant<size_t, Dims>...>,
-          detail::PropKind::WorkGroupSize, work_group_size_key> {
-  static_assert(
-      sizeof...(Dims) + 1 <= 3,
-      "work_group_size property currently only supports up to three values.");
-  static_assert(detail::FunctionPropertyAllNonZero<Dim0, Dims...>::value,
-                "work_group_size property must only contain non-zero values.");
-
-  constexpr size_t operator[](int Dim) const {
-    constexpr size_t Values[] = {Dim0, Dims...};
-    return Values[Dim];
-  }
-
-private:
-  constexpr size_t size() const { return sizeof...(Dims) + 1; }
-
-  template <typename, typename> friend struct detail::ConflictingProperties;
-};
-
-template <size_t Dim0, size_t... Dims>
-struct property_value<work_group_size_hint_key,
-                      std::integral_constant<size_t, Dim0>,
-                      std::integral_constant<size_t, Dims>...>
-    : detail::property_base<
-          property_value<work_group_size_hint_key,
-                         std::integral_constant<size_t, Dim0>,
-                         std::integral_constant<size_t, Dims>...>,
-          detail::PropKind::WorkGroupSizeHint, work_group_size_hint_key> {
-  static_assert(sizeof...(Dims) + 1 <= 3,
-                "work_group_size_hint property currently only supports up to "
-                "three values.");
-  static_assert(
-      detail::FunctionPropertyAllNonZero<Dim0, Dims...>::value,
-      "work_group_size_hint property must only contain non-zero values.");
-
-  constexpr size_t operator[](int Dim) const {
-    constexpr size_t Values[] = {Dim0, Dims...};
-    return Values[Dim];
-  }
-};
-
-template <uint32_t Size>
-struct property_value<sub_group_size_key,
-                      std::integral_constant<uint32_t, Size>>
-    : detail::property_base<
-          property_value<sub_group_size_key,
-                         std::integral_constant<uint32_t, Size>>,
-          detail::PropKind::SubGroupSize, sub_group_size_key> {
-  static_assert(Size != 0,
-                "sub_group_size property must contain a non-zero value.");
-
-  using value_t = std::integral_constant<uint32_t, Size>;
-  static constexpr uint32_t value = Size;
-};
-
-template <size_t Dim0, size_t... Dims>
-struct property_value<max_work_group_size_key,
-                      std::integral_constant<size_t, Dim0>,
-                      std::integral_constant<size_t, Dims>...>
-    : detail::property_base<
-          property_value<max_work_group_size_key,
-                         std::integral_constant<size_t, Dim0>,
-                         std::integral_constant<size_t, Dims>...>,
-          detail::PropKind::MaxWorkGroupSize, max_work_group_size_key> {
-  static_assert(
-      sizeof...(Dims) + 1 <= 3,
-      "max_work_group_size currently only supports up to three values.");
-  static_assert(detail::FunctionPropertyAllNonZero<Dim0, Dims...>::value,
-                "max_work_group_size must only contain non-zero values.");
-
-  constexpr size_t operator[](int Dim) const {
-    constexpr size_t Values[] = {Dim0, Dims...};
-    return Values[Dim];
-  }
-
-private:
-  constexpr size_t size() const { return sizeof...(Dims) + 1; }
-
-  template <typename, typename> friend struct detail::ConflictingProperties;
-};
-
-template <size_t Size>
-struct property_value<max_linear_work_group_size_key,
-                      std::integral_constant<size_t, Size>>
-    : detail::property_base<
-          property_value<max_linear_work_group_size_key,
-                         std::integral_constant<size_t, Size>>,
-          detail::PropKind::MaxLinearWorkGroupSize,
-          max_linear_work_group_size_key> {
-  static_assert(Size != 0,
-                "max_linear_work_group_size must contain a non-zero value.");
-
-  using value_t = std::integral_constant<size_t, Size>;
-  static constexpr size_t value = Size;
-};
-
-template <size_t Dim0, size_t... Dims>
-inline constexpr work_group_size_key::value_t<Dim0, Dims...> work_group_size;
-
-template <size_t Dim0, size_t... Dims>
-inline constexpr work_group_size_hint_key::value_t<Dim0, Dims...>
-    work_group_size_hint;
-
-template <uint32_t Size>
-inline constexpr sub_group_size_key::value_t<Size> sub_group_size;
-
-template <size_t Dim0, size_t... Dims>
-inline constexpr max_work_group_size_key::value_t<Dim0, Dims...>
-    max_work_group_size;
-
-template <size_t Size>
-inline constexpr max_linear_work_group_size_key::value_t<Size>
-    max_linear_work_group_size;
-
-namespace detail {
-
-template <int Dims>
-struct FunctionPropertyMetaInfo<nd_range_kernel_key::value_t<Dims>> {
-  static constexpr const char *name = "sycl-nd-range-kernel";
-  static constexpr int value = Dims;
-};
-
-template <> struct FunctionPropertyMetaInfo<single_task_kernel_key::value_t> {
-  static constexpr const char *name = "sycl-single-task-kernel";
-  static constexpr int value = 0;
-};
-
-template <size_t... Dims>
-struct HasCompileTimeEffect<work_group_size_key::value_t<Dims...>>
-    : std::true_type {};
-template <size_t... Dims>
-struct HasCompileTimeEffect<work_group_size_hint_key::value_t<Dims...>>
-    : std::true_type {};
-template <uint32_t Size>
-struct HasCompileTimeEffect<sub_group_size_key::value_t<Size>>
-    : std::true_type {};
-template <size_t... Dims>
-struct HasCompileTimeEffect<max_work_group_size_key::value_t<Dims...>>
-    : std::true_type {};
-template <size_t Size>
-struct HasCompileTimeEffect<max_linear_work_group_size_key::value_t<Size>>
-    : std::true_type {};
-
-template <size_t Dim0, size_t... Dims>
-struct PropertyMetaInfo<work_group_size_key::value_t<Dim0, Dims...>> {
-  static constexpr const char *name = "sycl-work-group-size";
-  static constexpr const char *value =
-      FunctionPropertySizeListToStr<Dim0, Dims...>::value;
-};
-template <size_t Dim0, size_t... Dims>
-struct FunctionPropertyMetaInfo<work_group_size_key::value_t<Dim0, Dims...>> {
-  static constexpr const char *name = "sycl-work-group-size";
-  static constexpr const char *value =
-      FunctionPropertySizeListToStr<Dim0, Dims...>::value;
-};
-
-template <size_t Dim0, size_t... Dims>
-struct PropertyMetaInfo<work_group_size_hint_key::value_t<Dim0, Dims...>> {
-  static constexpr const char *name = "sycl-work-group-size-hint";
-  static constexpr const char *value =
-      FunctionPropertySizeListToStr<Dim0, Dims...>::value;
-};
-template <size_t Dim0, size_t... Dims>
-struct FunctionPropertyMetaInfo<
-    work_group_size_hint_key::value_t<Dim0, Dims...>> {
-  static constexpr const char *name = "sycl-work-group-size-hint";
-  static constexpr const char *value =
-      FunctionPropertySizeListToStr<Dim0, Dims...>::value;
-};
-
-template <uint32_t Size>
-struct PropertyMetaInfo<sub_group_size_key::value_t<Size>> {
-  static constexpr const char *name = "sycl-sub-group-size";
-  static constexpr uint32_t value = Size;
-};
-template <uint32_t Size>
-struct FunctionPropertyMetaInfo<sub_group_size_key::value_t<Size>> {
-  static constexpr const char *name = "sycl-sub-group-size";
-  static constexpr uint32_t value = Size;
-};
-
-template <size_t Dim0, size_t... Dims>
-struct PropertyMetaInfo<max_work_group_size_key::value_t<Dim0, Dims...>> {
-  static constexpr const char *name = "sycl-max-work-group-size";
-  static constexpr const char *value =
-      FunctionPropertySizeListToStr<Dim0, Dims...>::value;
-};
-template <size_t Dim0, size_t... Dims>
-struct FunctionPropertyMetaInfo<
-    max_work_group_size_key::value_t<Dim0, Dims...>> {
-  static constexpr const char *name = "sycl-max-work-group-size";
-  static constexpr const char *value =
-      FunctionPropertySizeListToStr<Dim0, Dims...>::value;
-};
-
-template <size_t Size>
-struct PropertyMetaInfo<max_linear_work_group_size_key::value_t<Size>> {
-  static constexpr const char *name = "sycl-max-linear-work-group-size";
-  static constexpr size_t value = Size;
-};
-template <size_t Size>
-struct FunctionPropertyMetaInfo<max_linear_work_group_size_key::value_t<Size>> {
-  static constexpr const char *name = "sycl-max-linear-work-group-size";
-  static constexpr size_t value = Size;
-};
-
-} // namespace detail
-} // namespace ext::oneapi::experimental
-} // namespace _V1
-} // namespace sycl
-
-#ifdef __SYCL_DEVICE_ONLY__
-#define SYCL_EXT_ONEAPI_FUNCTION_PROPERTY(PROP)                                \
-  [[__sycl_detail__::add_ir_attributes_function(                               \
-      sycl::ext::oneapi::experimental::detail::FunctionPropertyMetaInfo<       \
-          sycl::ext::oneapi::experimental::detail::remove_cvref_t<             \
-              decltype(PROP)>>::name,                                          \
-      sycl::ext::oneapi::experimental::detail::FunctionPropertyMetaInfo<       \
-          sycl::ext::oneapi::experimental::detail::remove_cvref_t<             \
-              decltype(PROP)>>::value)]]
-#else
-#define SYCL_EXT_ONEAPI_FUNCTION_PROPERTY(PROP)
-#endif
+// Compatibility shim for the legacy kernel_properties/* include path.
+// Delete this header when support for that include path is removed.
+#include <sycl/ext/oneapi/free_function_kernel_properties.hpp>
diff --git a/sycl/include/sycl/ext/oneapi/kernel_properties/properties.hpp b/sycl/include/sycl/ext/oneapi/kernel_properties/properties.hpp
index b26d68a4d3be1..11f58071799c1 100644
--- a/sycl/include/sycl/ext/oneapi/kernel_properties/properties.hpp
+++ b/sycl/include/sycl/ext/oneapi/kernel_properties/properties.hpp
@@ -1,4 +1,4 @@
-//==------- properties.hpp - SYCL properties associated with kernels -------==//
+//==------- properties.hpp - compatibility forwarding header --------------==//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
@@ -8,231 +8,6 @@
 
 #pragma once
 
-#include <array>                                             // for array
-#include <stddef.h>                                          // for size_t
-#include <stdint.h>                                          // for uint32_t
-#include <sycl/aspects.hpp>                                  // for aspect
-#include <sycl/ext/oneapi/experimental/forward_progress.hpp> // for forward_progress_guarantee enum
-#include <sycl/ext/oneapi/kernel_properties/function_properties.hpp>
-#include <sycl/ext/oneapi/properties/properties.hpp>
-#include <type_traits>                                   // for true_type
-#include <utility>                                       // for declval
-namespace sycl {
-inline namespace _V1 {
-namespace ext::oneapi::experimental {
-
-struct properties_tag {};
-
-struct device_has_key
-    : detail::compile_time_property_key<detail::PropKind::DeviceHas> {
-  template <aspect... Aspects>
-  using value_t = property_value<device_has_key,
-                                 std::integral_constant<aspect, Aspects>...>;
-};
-
-template <aspect... Aspects>
-struct property_value<device_has_key,
-                      std::integral_constant<aspect, Aspects>...>
-    : detail::property_base<
-          property_value<device_has_key,
-                         std::integral_constant<aspect, Aspects>...>,
-          detail::PropKind::DeviceHas, device_has_key> {
-  static constexpr std::array<aspect, sizeof...(Aspects)> value{Aspects...};
-};
-
-template <aspect... Aspects>
-inline constexpr device_has_key::value_t<Aspects...> device_has;
-
-struct work_group_progress_key
-    : detail::compile_time_property_key<detail::PropKind::WorkGroupProgress> {
-  template <forward_progress_guarantee Guarantee,
-            execution_scope CoordinationScope>
-  using value_t = property_value<
-      work_group_progress_key,
-      std::integral_constant<forward_progress_guarantee, Guarantee>,
-      std::integral_constant<execution_scope, CoordinationScope>>;
-};
-
-struct sub_group_progress_key
-    : detail::compile_time_property_key<detail::PropKind::SubGroupProgress> {
-  template <forward_progress_guarantee Guarantee,
-            execution_scope CoordinationScope>
-  using value_t = property_value<
-      sub_group_progress_key,
-      std::integral_constant<forward_progress_guarantee, Guarantee>,
-      std::integral_constant<execution_scope, CoordinationScope>>;
-};
-
-struct work_item_progress_key
-    : detail::compile_time_property_key<detail::PropKind::WorkItemProgress> {
-  template <forward_progress_guarantee Guarantee,
-            execution_scope CoordinationScope>
-  using value_t = property_value<
-      work_item_progress_key,
-      std::integral_constant<forward_progress_guarantee, Guarantee>,
-      std::integral_constant<execution_scope, CoordinationScope>>;
-};
-
-template <forward_progress_guarantee Guarantee,
-          execution_scope CoordinationScope>
-struct property_value<
-    work_group_progress_key,
-    std::integral_constant<forward_progress_guarantee, Guarantee>,
-    std::integral_constant<execution_scope, CoordinationScope>>
-    : detail::property_base<
-          property_value<
-              work_group_progress_key,
-              std::integral_constant<forward_progress_guarantee, Guarantee>,
-              std::integral_constant<execution_scope, CoordinationScope>>,
-          detail::PropKind::WorkGroupProgress, work_group_progress_key> {
-  static constexpr forward_progress_guarantee guarantee = Guarantee;
-  static constexpr execution_scope coordinationScope = CoordinationScope;
-};
-
-template <forward_progress_guarantee Guarantee,
-          execution_scope CoordinationScope>
-struct property_value<
-    sub_group_progress_key,
-    std::integral_constant<forward_progress_guarantee, Guarantee>,
-    std::integral_constant<execution_scope, CoordinationScope>>
-    : detail::property_base<
-          property_value<
-              sub_group_progress_key,
-              std::integral_constant<forward_progress_guarantee, Guarantee>,
-              std::integral_constant<execution_scope, CoordinationScope>>,
-          detail::PropKind::SubGroupProgress, sub_group_progress_key> {
-  static constexpr forward_progress_guarantee guarantee = Guarantee;
-  static constexpr execution_scope coordinationScope = CoordinationScope;
-};
-
-template <forward_progress_guarantee Guarantee,
-          execution_scope CoordinationScope>
-struct property_value<
-    work_item_progress_key,
-    std::integral_constant<forward_progress_guarantee, Guarantee>,
-    std::integral_constant<execution_scope, CoordinationScope>>
-    : detail::property_base<
-          property_value<
-              work_item_progress_key,
-              std::integral_constant<forward_progress_guarantee, Guarantee>,
-              std::integral_constant<execution_scope, CoordinationScope>>,
-          detail::PropKind::WorkItemProgress, work_item_progress_key> {
-  static constexpr forward_progress_guarantee guarantee = Guarantee;
-  static constexpr execution_scope coordinationScope = CoordinationScope;
-};
-
-template <forward_progress_guarantee Guarantee,
-          execution_scope CoordinationScope>
-inline constexpr work_group_progress_key::value_t<Guarantee, CoordinationScope>
-    work_group_progress;
-
-template <forward_progress_guarantee Guarantee,
-          execution_scope CoordinationScope>
-inline constexpr sub_group_progress_key::value_t<Guarantee, CoordinationScope>
-    sub_group_progress;
-
-template <forward_progress_guarantee Guarantee,
-          execution_scope CoordinationScope>
-inline constexpr work_item_progress_key::value_t<Guarantee, CoordinationScope>
-    work_item_progress;
-
-namespace detail {
-template <sycl::aspect... Aspects>
-struct HasCompileTimeEffect<device_has_key::value_t<Aspects...>>
-    : std::true_type {};
-template <aspect... Aspects>
-struct PropertyMetaInfo<device_has_key::value_t<Aspects...>> {
-  static constexpr const char *name = "sycl-device-has";
-  static constexpr const char *value =
-      SizeListToStr<static_cast<size_t>(Aspects)...>::value;
-};
-template <aspect... Aspects>
-struct FunctionPropertyMetaInfo<device_has_key::value_t<Aspects...>> {
-  static constexpr const char *name = "sycl-device-has";
-  static constexpr const char *value =
-      SizeListToStr<static_cast<size_t>(Aspects)...>::value;
-};
-
-template <typename T, typename = void>
-struct HasKernelPropertiesGetMethod : std::false_type {};
-
-template <typename T>
-struct HasKernelPropertiesGetMethod<T,
-                                    std::void_t<decltype(std::declval<T>().get(
-                                        std::declval<properties_tag>()))>>
-    : std::true_type {
-  using properties_t =
-      decltype(std::declval<T>().get(std::declval<properties_tag>()));
-};
-
-// If work_group_size and max_work_group_size coexist, check that the
-// dimensionality matches and that the required work-group size doesn't
-// trivially exceed the maximum size.
-template <typename Properties>
-struct ConflictingProperties<max_work_group_size_key, Properties> {
-  static constexpr bool value = []() constexpr {
-    if constexpr (Properties::template has_property<work_group_size_key>()) {
-      constexpr auto wg_size =
-          Properties::template get_property<work_group_size_key>();
-      constexpr auto max_wg_size =
-          Properties::template get_property<max_work_group_size_key>();
-      static_assert(
-          wg_size.size() == max_wg_size.size(),
-          "work_group_size and max_work_group_size dimensionality must match");
-      if constexpr (wg_size.size() == max_wg_size.size()) {
-        constexpr auto Dims = wg_size.size();
-        static_assert(Dims < 1 || wg_size[0] <= max_wg_size[0],
-                      "work_group_size must not exceed max_work_group_size");
-        static_assert(Dims < 2 || wg_size[1] <= max_wg_size[1],
-                      "work_group_size must not exceed max_work_group_size");
-        static_assert(Dims < 3 || wg_size[2] <= max_wg_size[2],
-                      "work_group_size must not exceed max_work_group_size");
-      }
-    }
-    return false;
-  }();
-};
-
-// If work_group_size and max_linear_work_group_size coexist, check that the
-// required linear work-group size doesn't trivially exceed the maximum size.
-template <typename Properties>
-struct ConflictingProperties<max_linear_work_group_size_key, Properties> {
-  static constexpr bool value = []() constexpr {
-    if constexpr (Properties::template has_property<work_group_size_key>()) {
-      constexpr auto wg_size =
-          Properties::template get_property<work_group_size_key>();
-      constexpr auto dims = wg_size.size();
-      constexpr auto linear_size = wg_size[0] * (dims > 1 ? wg_size[1] : 1) *
-                                   (dims > 2 ? wg_size[2] : 1);
-      constexpr auto max_linear_wg_size =
-          Properties::template get_property<max_linear_work_group_size_key>();
-      static_assert(
-          linear_size < max_linear_wg_size.value,
-          "work_group_size must not exceed max_linear_work_group_size");
-    }
-    return false;
-  }();
-};
-
-// If the kernel (last element in the parameter pack) has a get(properties_tag)
-// method, return the property list specified by this getter. Otherwise, return
-// an empty properety list.
-template <typename... RestT>
-auto RetrieveGetMethodPropertiesOrEmpty(RestT &&...Rest) {
-  // Note: the following trivial identity lambda is used to avoid the issue
-  // that line "const auto &KernelObj = (Rest, ...);" may result in a "left
-  // operand of comma operator has no effect" error for certain compiler(s)
-  auto Identity = [](const auto &x) -> decltype(auto) { return x; };
-  const auto &KernelObj = (Identity(Rest), ...);
-  if constexpr (ext::oneapi::experimental::detail::HasKernelPropertiesGetMethod<
-                    decltype(KernelObj)>::value) {
-    return KernelObj.get(ext::oneapi::experimental::properties_tag{});
-  } else {
-    return ext::oneapi::experimental::empty_properties_t{};
-  }
-}
-
-} // namespace detail
-} // namespace ext::oneapi::experimental
-} // namespace _V1
-} // namespace sycl
+// Compatibility shim for the legacy kernel_properties/* include path.
+// Delete this header when support for that include path is removed.
+#include <sycl/ext/oneapi/kernel_properties.hpp>
diff --git a/sycl/include/sycl/ext/oneapi/properties.hpp b/sycl/include/sycl/ext/oneapi/properties.hpp
new file mode 100644
index 0000000000000..158e75e49b682
--- /dev/null
+++ b/sycl/include/sycl/ext/oneapi/properties.hpp
@@ -0,0 +1,421 @@
+//==---------------- properties.hpp - SYCL oneAPI properties --------------==//
+//
+// 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/ext/oneapi/properties/property_utils.hpp>
+
+#include <array>
+#include <cstddef>
+#include <type_traits>
+#include <utility>
+
+namespace sycl {
+inline namespace _V1 {
+namespace detail {}
+namespace ext::oneapi::experimental {
+
+template <typename properties_type_list_ty> class __SYCL_EBO properties;
+
+namespace detail {
+using namespace sycl::detail;
+
+// Keep a distinct name for the local helper to avoid colliding with the
+// imported sycl::detail::nth_type_t alias.
+#if __has_builtin(__type_pack_element)
+template <int N, typename... Ts>
+using properties_nth_type_t = __type_pack_element<N, Ts...>;
+#else
+template <int N, typename T, typename... Ts> struct nth_type {
+	using type = typename nth_type<N - 1, Ts...>::type;
+};
+
+template <typename T, typename... Ts> struct nth_type<0, T, Ts...> {
+	using type = T;
+};
+
+template <int N, typename... Ts>
+using properties_nth_type_t = typename nth_type<N, Ts...>::type;
+#endif
+
+// NOTE: Meta-function to implement CTAD rules isn't allowed to return
+// `properties<something>` and it's impossible to return a pack as well. As
+// such, we're forced to have an extra level of `detail::properties_type_list`
+// for the purpose of providing CTAD rules.
+template <typename... property_tys> struct properties_type_list;
+
+// This is used in a separate `properties` specialization to report friendlier
+// errors.
+template <typename... property_tys> struct invalid_properties_type_list {};
+
+// Helper for reconstructing a properties type. This assumes that
+// PropertyValueTs is sorted and contains only valid properties.
+//
+// It also allows us to hide details of `properties` implementation from the
+// code that uses/defines them (with the exception of ESIMD which is extremely
+// hacky in its own esimd::properties piggybacking on these ones).
+template <typename... PropertyValueTs>
+using properties_t =
+		properties<detail::properties_type_list<PropertyValueTs...>>;
+
+template <typename... property_tys>
+inline constexpr bool properties_are_unique = []() constexpr -> bool {
+	if constexpr (sizeof...(property_tys) == 0) {
+		return true;
+	} else {
+		const std::array kinds = {PropertyID<property_tys>::value...};
+		auto N = kinds.size();
+		for (std::size_t i = 0; i < N; ++i)
+			for (std::size_t j = i + 1; j < N; ++j)
+				if (kinds[i] == kinds[j])
+					return false;
+
+		return true;
+	}
+}();
+
+template <typename... property_tys>
+inline constexpr bool properties_are_sorted = []() constexpr -> bool {
+	if constexpr (sizeof...(property_tys) == 0) {
+		return true;
+	} else {
+		const std::array kinds = {PropertyID<property_tys>::value...};
+		// std::is_sorted isn't constexpr until C++20.
+		for (std::size_t idx = 1; idx < kinds.size(); ++idx)
+			if (kinds[idx - 1] >= kinds[idx])
+				return false;
+		return true;
+	}
+}();
+
+template <typename... property_tys>
+constexpr bool properties_are_valid_for_ctad = []() constexpr {
+	// Need `if constexpr` to avoid hard error in "unique" check when querying
+	// property kind if `property_tys` isn't a property.
+	if constexpr (!((is_property_value_v<property_tys> && ...))) {
+		return false;
+	} else if constexpr (!detail::properties_are_unique<property_tys...>) {
+		return false;
+	} else {
+		return true;
+	}
+}();
+
+template <typename... property_tys> struct properties_sorter {
+	// Not using "auto" due to MSVC bug in v19.36 and older. v19.37 and later is
+	// able to compile "auto" just fine. See https://godbolt.org/z/eW3rjjs7n.
+	static constexpr std::array<int, sizeof...(property_tys)> sorted_indices =
+			[]() constexpr {
+				int idx = 0;
+				int N = sizeof...(property_tys);
+				// std::sort isn't constexpr until C++20. Also, it's possible there will
+				// be a compiler builtin to sort types, in which case we should start
+				// using that.
+				std::array to_sort{
+						std::pair{PropertyID<property_tys>::value, idx++}...};
+				auto swap_pair = [](auto &x, auto &y) constexpr {
+					auto tmp_first = x.first;
+					auto tmp_second = x.second;
+					x.first = y.first;
+					x.second = y.second;
+					y.first = tmp_first;
+					y.second = tmp_second;
+				};
+				for (int i = 0; i < N; ++i)
+					for (int j = i; j < N; ++j)
+						if (to_sort[j].first < to_sort[i].first)
+							swap_pair(to_sort[i], to_sort[j]);
+
+				std::array<int, sizeof...(property_tys)> sorted_indices{};
+				for (int i = 0; i < N; ++i)
+					sorted_indices[i] = to_sort[i].second;
+
+				return sorted_indices;
+			}();
+
+	template <typename> struct helper;
+	template <int... IdxSeq>
+	struct helper<std::integer_sequence<int, IdxSeq...>> {
+		using type = properties_type_list<
+				properties_nth_type_t<sorted_indices[IdxSeq], property_tys...>...>;
+	};
+
+	using type = typename helper<
+			std::make_integer_sequence<int, sizeof...(property_tys)>>::type;
+};
+// Specialization to avoid zero-size array creation.
+template <> struct properties_sorter<> {
+	using type = properties_type_list<>;
+};
+
+} // namespace detail
+
+// Empty property list.
+template <> class __SYCL_EBO properties<detail::properties_type_list<>> {
+	template <typename T>
+	static constexpr bool empty_properties_list_contains = false;
+
+public:
+	template <typename property_key_t> static constexpr bool has_property() {
+		return false;
+	}
+
+	// Never exists for empty property list, provide this for a better error
+	// message:
+	template <typename T>
+	static std::enable_if_t<empty_properties_list_contains<T>> get_property() {}
+};
+
+// Base implementation to provide nice user error in case of mis-use. Without it
+// an error "base class '<property>' specified more than once as a direct base
+// class" is reported prior to static_assert's error.
+template <typename... property_tys>
+class __SYCL_EBO
+		properties<detail::invalid_properties_type_list<property_tys...>> {
+public:
+	properties(property_tys...) {
+		if constexpr (!((is_property_value_v<property_tys> && ...))) {
+			static_assert(((is_property_value_v<property_tys> && ...)),
+										"Non-property argument!");
+		} else {
+			// This is a separate specialization to report an error, we can afford
+			// doing extra work to provide nice error message without sacrificing
+			// compile time on non-exceptional path. Let's find *a* pair of properties
+			// that failed the check. Note that there might be multiple duplicate
+			// names, we're only reporting one instance. Once user addresses that, the
+			// next pair will be reported.
+			static constexpr auto conflict = []() constexpr {
+				const std::array kinds = {detail::PropertyID<property_tys>::value...};
+				auto N = kinds.size();
+				for (int i = 0; i < N; ++i)
+					for (int j = i + 1; j < N; ++j)
+						if (kinds[i] == kinds[j])
+							return std::pair{i, j};
+			}();
+			using first_type =
+					detail::properties_nth_type_t<conflict.first, property_tys...>;
+			using second_type =
+					detail::properties_nth_type_t<conflict.second, property_tys...>;
+			if constexpr (std::is_same_v<typename first_type::key_t,
+																	 typename second_type::key_t>) {
+				static_assert(!std::is_same_v<typename first_type::key_t,
+																			typename second_type::key_t>,
+											"Duplicate properties in property list.");
+			} else {
+				static_assert(
+						detail::PropertyToKind<first_type>::Kind !=
+								detail::PropertyToKind<second_type>::Kind,
+						"Property Kind collision between different property keys!");
+			}
+		}
+	}
+
+	template <typename property_key_t> static constexpr bool has_property() {
+		return false;
+	}
+};
+
+template <typename... property_tys>
+class __SYCL_EBO properties<detail::properties_type_list<property_tys...>>
+		: private property_tys... {
+	static_assert(detail::properties_are_sorted<property_tys...>,
+								"Properties must be sorted!");
+	using property_tys::get_property_impl...;
+
+	template <typename> friend class __SYCL_EBO properties;
+
+	template <typename prop_t> static constexpr bool is_valid_ctor_arg() {
+		return ((std::is_same_v<prop_t, property_tys> || ...));
+	}
+
+	template <typename prop_t, typename... unsorted_property_tys>
+	static constexpr bool can_be_constructed_from() {
+		return std::is_default_constructible_v<prop_t> ||
+					 ((false || ... || std::is_same_v<prop_t, unsorted_property_tys>));
+	}
+
+	// It's possible it shouldn't be that complicated, but clang doesn't accept
+	// simpler version: https://godbolt.org/z/oPff4h738, reported upstream at
+	// https://github.com/llvm/llvm-project/issues/115547. Note that if the
+	// `decltype(...)` is "inlined" then it has no issues with it, but that's too
+	// verbose.
+	struct helper : property_tys... {
+		using property_tys::get_property_impl...;
+	};
+	template <typename property_key_t>
+	using prop_t = decltype(std::declval<helper>().get_property_impl(
+			detail::property_key_tag<property_key_t>{}));
+
+public:
+	template <
+			typename... unsorted_property_tys,
+			typename = std::enable_if_t<
+					((is_valid_ctor_arg<unsorted_property_tys>() && ...))>,
+			typename = std::enable_if_t<
+					((can_be_constructed_from<property_tys, unsorted_property_tys...>() &&
+						...))>,
+			typename = std::enable_if_t<
+					detail::properties_are_unique<unsorted_property_tys...>>>
+	constexpr properties(unsorted_property_tys... props);
+
+	template <typename property_key_t> static constexpr bool has_property() {
+		return std::is_base_of_v<detail::property_key_tag<property_key_t>,
+														 properties>;
+	}
+
+	template <typename property_key_t>
+	static constexpr auto
+	get_property() -> std::enable_if_t<std::is_empty_v<prop_t<property_key_t>>,
+																		 prop_t<property_key_t>> {
+		return prop_t<property_key_t>{};
+	}
+
+	template <typename property_key_t>
+	constexpr auto get_property(int = 0) const
+			-> std::enable_if_t<!std::is_empty_v<prop_t<property_key_t>>,
+													prop_t<property_key_t>> {
+		return get_property_impl(detail::property_key_tag<property_key_t>{});
+	}
+};
+
+template <typename... property_tys>
+template <typename... unsorted_property_tys, typename, typename, typename>
+constexpr properties<detail::properties_type_list<property_tys...>>::properties(
+		unsorted_property_tys... props)
+		: unsorted_property_tys(props)... {
+	static_assert(((!detail::ConflictingProperties<typename property_tys::key_t,
+																								 properties>::value &&
+									...)),
+								"Conflicting properties in property list.");
+}
+
+template <typename... unsorted_property_tys,
+					typename = std::enable_if_t<
+							detail::properties_are_valid_for_ctad<unsorted_property_tys...>>>
+properties(unsorted_property_tys... props)
+		-> properties<
+				typename detail::properties_sorter<unsorted_property_tys...>::type>;
+
+template <typename... unsorted_property_tys,
+					typename = std::enable_if_t<
+							!detail::properties_are_valid_for_ctad<unsorted_property_tys...>>>
+properties(unsorted_property_tys... props)
+		-> properties<
+				detail::invalid_properties_type_list<unsorted_property_tys...>>;
+
+using empty_properties_t = decltype(properties{});
+
+namespace detail {
+
+template <template <typename> typename predicate, typename... property_tys>
+struct filter_properties_impl {
+	static constexpr auto idx_info = []() constexpr {
+		constexpr int N = sizeof...(property_tys);
+		std::array<int, N> indexes{};
+		int num_matched = 0;
+		int idx = 0;
+		(((predicate<property_tys>::value ? indexes[num_matched++] = idx++ : idx++),
+			...));
+
+		return std::pair{indexes, num_matched};
+	}();
+
+	template <int... Idx>
+	static constexpr auto idx_seq(std::integer_sequence<int, Idx...>) {
+		return std::integer_sequence<int, idx_info.first[Idx]...>{};
+	}
+
+	using selected_idx_seq =
+			decltype(idx_seq(std::make_integer_sequence<int, idx_info.second>{}));
+
+	template <typename prop_list_ty, int... Idxs>
+	static constexpr auto apply_impl(const prop_list_ty &props,
+																	 std::integer_sequence<int, Idxs...>) {
+		return properties{props.template get_property<
+				typename properties_nth_type_t<Idxs, property_tys...>::key_t>()...};
+	}
+
+	template <typename prop_list_ty>
+	static constexpr auto apply(const prop_list_ty &props) {
+		return apply_impl(props, selected_idx_seq{});
+	}
+};
+
+template <template <typename> typename predicate, typename... property_tys>
+constexpr auto filter_properties(const properties_t<property_tys...> &props) {
+	return filter_properties_impl<predicate, property_tys...>::apply(props);
+}
+
+template <typename... lhs_property_tys> struct merge_filter {
+	template <typename rhs_property_ty>
+	struct predicate
+			: std::bool_constant<!((std::is_same_v<typename lhs_property_tys::key_t,
+																						 typename rhs_property_ty::key_t> ||
+															...))> {};
+};
+
+template <typename... lhs_property_tys, typename... rhs_property_tys>
+constexpr auto merge_properties(const properties_t<lhs_property_tys...> &lhs,
+																const properties_t<rhs_property_tys...> &rhs) {
+	auto rhs_unique_props =
+			filter_properties<merge_filter<lhs_property_tys...>::template predicate>(
+					rhs);
+	if constexpr (std::is_same_v<std::decay_t<decltype(rhs)>,
+															 std::decay_t<decltype(rhs_unique_props)>>) {
+		return properties{
+				lhs.template get_property<typename lhs_property_tys::key_t>()...,
+				rhs.template get_property<typename rhs_property_tys::key_t>()...};
+	} else {
+		constexpr auto has_conflict = [](auto *lhs_prop) constexpr {
+			using lhs_property_ty = std::remove_pointer_t<decltype(lhs_prop)>;
+			return (((std::is_same_v<typename lhs_property_ty::key_t,
+															 typename rhs_property_tys::key_t> &&
+								(!std::is_same_v<lhs_property_ty, rhs_property_tys> ||
+								 !std::is_empty_v<lhs_property_ty>)) ||
+							 ...));
+		};
+		static_assert(
+				!((has_conflict(static_cast<lhs_property_tys *>(nullptr)) || ...)),
+				"Failed to merge property lists due to conflicting properties.");
+		return merge_properties(lhs, rhs_unique_props);
+	}
+}
+
+template <typename LHSPropertiesT, typename RHSPropertiesT>
+using merged_properties_t = decltype(merge_properties(
+		std::declval<LHSPropertiesT>(), std::declval<RHSPropertiesT>()));
+
+template <typename property_key_t, typename prop_list_t, typename default_t>
+constexpr auto get_property_or(default_t value, const prop_list_t &props) {
+	if constexpr (prop_list_t::template has_property<property_key_t>())
+		return props.template get_property<property_key_t>();
+	else
+		return value;
+}
+template <typename property_key_t, typename prop_list_t, typename default_t>
+constexpr auto get_property_or(default_t value) {
+	if constexpr (prop_list_t::template has_property<property_key_t>())
+		return prop_list_t::template get_property<property_key_t>();
+	else
+		return value;
+}
+
+template <typename SyclT, typename PropListT>
+struct all_are_properties_of : std::false_type {};
+template <typename SyclT, typename... Props>
+struct all_are_properties_of<SyclT, properties_t<Props...>>
+		: std::bool_constant<((is_property_value_of<Props, SyclT>::value && ...))> {
+};
+template <typename SyclT, typename PropListT>
+inline constexpr bool all_are_properties_of_v =
+		all_are_properties_of<SyclT, PropListT>::value;
+
+} // namespace detail
+} // namespace ext::oneapi::experimental
+} // namespace _V1
+} // namespace sycl
\ No newline at end of file
diff --git a/sycl/include/sycl/ext/oneapi/properties/properties.hpp b/sycl/include/sycl/ext/oneapi/properties/properties.hpp
index 5ea968f44a260..06a94bafe9274 100644
--- a/sycl/include/sycl/ext/oneapi/properties/properties.hpp
+++ b/sycl/include/sycl/ext/oneapi/properties/properties.hpp
@@ -1,4 +1,4 @@
-//==---------- properties.hpp --- SYCL extended property list --------------==//
+//==---------- properties.hpp - compatibility forwarding header ------------==//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
@@ -8,428 +8,4 @@
 
 #pragma once
 
-#include <sycl/ext/oneapi/properties/property_utils.hpp>
-
-#include <array>
-#include <cstddef>
-#include <type_traits>
-#include <utility>
-
-namespace sycl {
-inline namespace _V1 {
-namespace detail {}
-namespace ext::oneapi::experimental {
-
-template <typename properties_type_list_ty> class __SYCL_EBO properties;
-
-namespace detail {
-using namespace sycl::detail;
-
-// Keep a distinct name for the local helper to avoid colliding with the
-// imported sycl::detail::nth_type_t alias.
-#if __has_builtin(__type_pack_element)
-template <int N, typename... Ts>
-using properties_nth_type_t = __type_pack_element<N, Ts...>;
-#else
-template <int N, typename T, typename... Ts> struct nth_type {
-  using type = typename nth_type<N - 1, Ts...>::type;
-};
-
-template <typename T, typename... Ts> struct nth_type<0, T, Ts...> {
-  using type = T;
-};
-
-template <int N, typename... Ts>
-using properties_nth_type_t = typename nth_type<N, Ts...>::type;
-#endif
-
-// NOTE: Meta-function to implement CTAD rules isn't allowed to return
-// `properties<something>` and it's impossible to return a pack as well. As
-// such, we're forced to have an extra level of `detail::properties_type_list`
-// for the purpose of providing CTAD rules.
-template <typename... property_tys> struct properties_type_list;
-
-// This is used in a separate `properties` specialization to report friendlier
-// errors.
-template <typename... property_tys> struct invalid_properties_type_list {};
-
-// Helper for reconstructing a properties type. This assumes that
-// PropertyValueTs is sorted and contains only valid properties.
-//
-// It also allows us to hide details of `properties` implementation from the
-// code that uses/defines them (with the exception of ESIMD which is extremely
-// hacky in its own esimd::properties piggybacking on these ones).
-template <typename... PropertyValueTs>
-using properties_t =
-    properties<detail::properties_type_list<PropertyValueTs...>>;
-
-template <typename... property_tys>
-inline constexpr bool properties_are_unique = []() constexpr -> bool {
-  if constexpr (sizeof...(property_tys) == 0) {
-    return true;
-  } else {
-    const std::array kinds = {PropertyID<property_tys>::value...};
-    auto N = kinds.size();
-    for (std::size_t i = 0; i < N; ++i)
-      for (std::size_t j = i + 1; j < N; ++j)
-        if (kinds[i] == kinds[j])
-          return false;
-
-    return true;
-  }
-}();
-
-template <typename... property_tys>
-inline constexpr bool properties_are_sorted = []() constexpr -> bool {
-  if constexpr (sizeof...(property_tys) == 0) {
-    return true;
-  } else {
-    const std::array kinds = {PropertyID<property_tys>::value...};
-    // std::is_sorted isn't constexpr until C++20.
-    for (std::size_t idx = 1; idx < kinds.size(); ++idx)
-      if (kinds[idx - 1] >= kinds[idx])
-        return false;
-    return true;
-  }
-}();
-
-template <typename... property_tys>
-constexpr bool properties_are_valid_for_ctad = []() constexpr {
-  // Need `if constexpr` to avoid hard error in "unique" check when querying
-  // property kind if `property_tys` isn't a property.
-  if constexpr (!((is_property_value_v<property_tys> && ...))) {
-    return false;
-  } else if constexpr (!detail::properties_are_unique<property_tys...>) {
-    return false;
-  } else {
-    return true;
-  }
-}();
-
-template <typename... property_tys> struct properties_sorter {
-  // Not using "auto" due to MSVC bug in v19.36 and older. v19.37 and later is
-  // able to compile "auto" just fine. See https://godbolt.org/z/eW3rjjs7n.
-  static constexpr std::array<int, sizeof...(property_tys)> sorted_indices =
-      []() constexpr {
-        int idx = 0;
-        int N = sizeof...(property_tys);
-        // std::sort isn't constexpr until C++20. Also, it's possible there will
-        // be a compiler builtin to sort types, in which case we should start
-        // using that.
-        std::array to_sort{
-            std::pair{PropertyID<property_tys>::value, idx++}...};
-        auto swap_pair = [](auto &x, auto &y) constexpr {
-          auto tmp_first = x.first;
-          auto tmp_second = x.second;
-          x.first = y.first;
-          x.second = y.second;
-          y.first = tmp_first;
-          y.second = tmp_second;
-        };
-        for (int i = 0; i < N; ++i)
-          for (int j = i; j < N; ++j)
-            if (to_sort[j].first < to_sort[i].first)
-              swap_pair(to_sort[i], to_sort[j]);
-
-        std::array<int, sizeof...(property_tys)> sorted_indices{};
-        for (int i = 0; i < N; ++i)
-          sorted_indices[i] = to_sort[i].second;
-
-        return sorted_indices;
-      }();
-
-  template <typename> struct helper;
-  template <int... IdxSeq>
-  struct helper<std::integer_sequence<int, IdxSeq...>> {
-    using type = properties_type_list<
-        properties_nth_type_t<sorted_indices[IdxSeq], property_tys...>...>;
-  };
-
-  using type = typename helper<
-      std::make_integer_sequence<int, sizeof...(property_tys)>>::type;
-};
-// Specialization to avoid zero-size array creation.
-template <> struct properties_sorter<> {
-  using type = properties_type_list<>;
-};
-
-} // namespace detail
-
-// Empty property list.
-template <> class __SYCL_EBO properties<detail::properties_type_list<>> {
-  template <typename T>
-  static constexpr bool empty_properties_list_contains = false;
-
-public:
-  template <typename property_key_t> static constexpr bool has_property() {
-    return false;
-  }
-
-  // Never exists for empty property list, provide this for a better error
-  // message:
-  template <typename T>
-  static std::enable_if_t<empty_properties_list_contains<T>> get_property() {}
-};
-
-// Base implementation to provide nice user error in case of mis-use. Without it
-// an error "base class '<property>' specified more than once as a direct base
-// class" is reported prior to static_assert's error.
-template <typename... property_tys>
-class __SYCL_EBO
-    properties<detail::invalid_properties_type_list<property_tys...>> {
-public:
-  properties(property_tys...) {
-    if constexpr (!((is_property_value_v<property_tys> && ...))) {
-      static_assert(((is_property_value_v<property_tys> && ...)),
-                    "Non-property argument!");
-    } else {
-      // This is a separate specialization to report an error, we can afford
-      // doing extra work to provide nice error message without sacrificing
-      // compile time on non-exceptional path. Let's find *a* pair of properties
-      // that failed the check. Note that there might be multiple duplicate
-      // names, we're only reporting one instance. Once user addresses that, the
-      // next pair will be reported.
-      static constexpr auto conflict = []() constexpr {
-        const std::array kinds = {detail::PropertyID<property_tys>::value...};
-        auto N = kinds.size();
-        for (int i = 0; i < N; ++i)
-          for (int j = i + 1; j < N; ++j)
-            if (kinds[i] == kinds[j])
-              return std::pair{i, j};
-      }();
-      using first_type =
-          detail::properties_nth_type_t<conflict.first, property_tys...>;
-      using second_type =
-          detail::properties_nth_type_t<conflict.second, property_tys...>;
-      if constexpr (std::is_same_v<typename first_type::key_t,
-                                   typename second_type::key_t>) {
-        static_assert(!std::is_same_v<typename first_type::key_t,
-                                      typename second_type::key_t>,
-                      "Duplicate properties in property list.");
-      } else {
-        static_assert(
-            detail::PropertyToKind<first_type>::Kind !=
-                detail::PropertyToKind<second_type>::Kind,
-            "Property Kind collision between different property keys!");
-      }
-    }
-  }
-
-  template <typename property_key_t> static constexpr bool has_property() {
-    return false;
-  }
-};
-
-template <typename... property_tys>
-class __SYCL_EBO properties<detail::properties_type_list<property_tys...>>
-    : private property_tys... {
-  static_assert(detail::properties_are_sorted<property_tys...>,
-                "Properties must be sorted!");
-  using property_tys::get_property_impl...;
-
-  template <typename> friend class __SYCL_EBO properties;
-
-  template <typename prop_t> static constexpr bool is_valid_ctor_arg() {
-    return ((std::is_same_v<prop_t, property_tys> || ...));
-  }
-
-  template <typename prop_t, typename... unsorted_property_tys>
-  static constexpr bool can_be_constructed_from() {
-    return std::is_default_constructible_v<prop_t> ||
-           ((false || ... || std::is_same_v<prop_t, unsorted_property_tys>));
-  }
-
-  // It's possible it shouldn't be that complicated, but clang doesn't accept
-  // simpler version: https://godbolt.org/z/oPff4h738, reported upstream at
-  // https://github.com/llvm/llvm-project/issues/115547. Note that if the
-  // `decltype(...)` is "inlined" then it has no issues with it, but that's too
-  // verbose.
-  struct helper : property_tys... {
-    using property_tys::get_property_impl...;
-  };
-  template <typename property_key_t>
-  using prop_t = decltype(std::declval<helper>().get_property_impl(
-      detail::property_key_tag<property_key_t>{}));
-
-public:
-  // Definition is out-of-class so that `properties` would be complete there and
-  // its interfaces could be used in `ConflictingProperties`' partial
-  // specializations.
-  template <
-      typename... unsorted_property_tys,
-      typename = std::enable_if_t<
-          ((is_valid_ctor_arg<unsorted_property_tys>() && ...))>,
-      typename = std::enable_if_t<
-          ((can_be_constructed_from<property_tys, unsorted_property_tys...>() &&
-            ...))>,
-      typename = std::enable_if_t<
-          detail::properties_are_unique<unsorted_property_tys...>>>
-  constexpr properties(unsorted_property_tys... props);
-
-  template <typename property_key_t> static constexpr bool has_property() {
-    return std::is_base_of_v<detail::property_key_tag<property_key_t>,
-                             properties>;
-  }
-
-  // Compile-time property.
-  template <typename property_key_t>
-  static constexpr auto
-  get_property() -> std::enable_if_t<std::is_empty_v<prop_t<property_key_t>>,
-                                     prop_t<property_key_t>> {
-    return prop_t<property_key_t>{};
-  }
-
-  // Runtime property.
-  // Extra operand to make MSVC happy as it complains otherwise:
-  // https://godbolt.org/z/WGqdqrejj
-  template <typename property_key_t>
-  constexpr auto get_property(int = 0) const
-      -> std::enable_if_t<!std::is_empty_v<prop_t<property_key_t>>,
-                          prop_t<property_key_t>> {
-    return get_property_impl(detail::property_key_tag<property_key_t>{});
-  }
-};
-
-template <typename... property_tys>
-template <typename... unsorted_property_tys, typename, typename, typename>
-constexpr properties<detail::properties_type_list<property_tys...>>::properties(
-    unsorted_property_tys... props)
-    : unsorted_property_tys(props)... {
-  static_assert(((!detail::ConflictingProperties<typename property_tys::key_t,
-                                                 properties>::value &&
-                  ...)),
-                "Conflicting properties in property list.");
-}
-
-// Deduction guides
-template <typename... unsorted_property_tys,
-          typename = std::enable_if_t<
-              detail::properties_are_valid_for_ctad<unsorted_property_tys...>>>
-properties(unsorted_property_tys... props)
-    -> properties<
-        typename detail::properties_sorter<unsorted_property_tys...>::type>;
-
-template <typename... unsorted_property_tys,
-          typename = std::enable_if_t<
-              !detail::properties_are_valid_for_ctad<unsorted_property_tys...>>>
-properties(unsorted_property_tys... props)
-    -> properties<
-        detail::invalid_properties_type_list<unsorted_property_tys...>>;
-
-using empty_properties_t = decltype(properties{});
-
-namespace detail {
-
-template <template <typename> typename predicate, typename... property_tys>
-struct filter_properties_impl {
-  static constexpr auto idx_info = []() constexpr {
-    constexpr int N = sizeof...(property_tys);
-    std::array<int, N> indexes{};
-    int num_matched = 0;
-    int idx = 0;
-    (((predicate<property_tys>::value ? indexes[num_matched++] = idx++ : idx++),
-      ...));
-
-    return std::pair{indexes, num_matched};
-  }();
-
-  // Helper to convert constexpr indices values to an std::index_sequence type.
-  // Values -> type is the key here.
-  template <int... Idx>
-  static constexpr auto idx_seq(std::integer_sequence<int, Idx...>) {
-    return std::integer_sequence<int, idx_info.first[Idx]...>{};
-  }
-
-  using selected_idx_seq =
-      decltype(idx_seq(std::make_integer_sequence<int, idx_info.second>{}));
-
-  // Using prop_list_ty so that we don't need to explicitly spell out
-  //  `properties` template parameters' implementation-details.
-  template <typename prop_list_ty, int... Idxs>
-  static constexpr auto apply_impl(const prop_list_ty &props,
-                                   std::integer_sequence<int, Idxs...>) {
-    return properties{props.template get_property<
-        typename properties_nth_type_t<Idxs, property_tys...>::key_t>()...};
-  }
-
-  template <typename prop_list_ty>
-  static constexpr auto apply(const prop_list_ty &props) {
-    return apply_impl(props, selected_idx_seq{});
-  }
-};
-
-template <template <typename> typename predicate, typename... property_tys>
-constexpr auto filter_properties(const properties_t<property_tys...> &props) {
-  return filter_properties_impl<predicate, property_tys...>::apply(props);
-}
-
-template <typename... lhs_property_tys> struct merge_filter {
-  template <typename rhs_property_ty>
-  struct predicate
-      : std::bool_constant<!((std::is_same_v<typename lhs_property_tys::key_t,
-                                             typename rhs_property_ty::key_t> ||
-                              ...))> {};
-};
-
-template <typename... lhs_property_tys, typename... rhs_property_tys>
-constexpr auto merge_properties(const properties_t<lhs_property_tys...> &lhs,
-                                const properties_t<rhs_property_tys...> &rhs) {
-  auto rhs_unique_props =
-      filter_properties<merge_filter<lhs_property_tys...>::template predicate>(
-          rhs);
-  if constexpr (std::is_same_v<std::decay_t<decltype(rhs)>,
-                               std::decay_t<decltype(rhs_unique_props)>>) {
-    // None of RHS properties share keys with LHS, no conflicts possible.
-    return properties{
-        lhs.template get_property<typename lhs_property_tys::key_t>()...,
-        rhs.template get_property<typename rhs_property_tys::key_t>()...};
-  } else {
-    // Ensure no conflicts, then merge.
-    constexpr auto has_conflict = [](auto *lhs_prop) constexpr {
-      using lhs_property_ty = std::remove_pointer_t<decltype(lhs_prop)>;
-      return (((std::is_same_v<typename lhs_property_ty::key_t,
-                               typename rhs_property_tys::key_t> &&
-                (!std::is_same_v<lhs_property_ty, rhs_property_tys> ||
-                 !std::is_empty_v<lhs_property_ty>)) ||
-               ...));
-    };
-    static_assert(
-        !((has_conflict(static_cast<lhs_property_tys *>(nullptr)) || ...)),
-        "Failed to merge property lists due to conflicting properties.");
-    return merge_properties(lhs, rhs_unique_props);
-  }
-}
-
-template <typename LHSPropertiesT, typename RHSPropertiesT>
-using merged_properties_t = decltype(merge_properties(
-    std::declval<LHSPropertiesT>(), std::declval<RHSPropertiesT>()));
-
-template <typename property_key_t, typename prop_list_t, typename default_t>
-constexpr auto get_property_or(default_t value, const prop_list_t &props) {
-  if constexpr (prop_list_t::template has_property<property_key_t>())
-    return props.template get_property<property_key_t>();
-  else
-    return value;
-}
-template <typename property_key_t, typename prop_list_t, typename default_t>
-constexpr auto get_property_or(default_t value) {
-  if constexpr (prop_list_t::template has_property<property_key_t>())
-    return prop_list_t::template get_property<property_key_t>();
-  else
-    return value;
-}
-
-template <typename SyclT, typename PropListT>
-struct all_are_properties_of : std::false_type /* not a properties list */ {};
-template <typename SyclT, typename... Props>
-struct all_are_properties_of<SyclT, properties_t<Props...>>
-    : std::bool_constant<((is_property_value_of<Props, SyclT>::value && ...))> {
-};
-template <typename SyclT, typename PropListT>
-inline constexpr bool all_are_properties_of_v =
-    all_are_properties_of<SyclT, PropListT>::value;
-
-} // namespace detail
-} // namespace ext::oneapi::experimental
-} // namespace _V1
-} // namespace sycl
+#include <sycl/ext/oneapi/properties.hpp>
diff --git a/sycl/include/sycl/ext/oneapi/work_group_scratch_memory.hpp b/sycl/include/sycl/ext/oneapi/work_group_scratch_memory.hpp
index bf7cc05a728bb..d67f523a73dcb 100644
--- a/sycl/include/sycl/ext/oneapi/work_group_scratch_memory.hpp
+++ b/sycl/include/sycl/ext/oneapi/work_group_scratch_memory.hpp
@@ -10,7 +10,7 @@
 #include <sycl/detail/defines_elementary.hpp>      // for __SYCL_ALWAYS_INLINE
 #include <sycl/detail/sycl_local_mem_builtins.hpp> // for __sycl_allocateLocalMemory
 #include <sycl/exception.hpp>                      // for exception
-#include <sycl/ext/oneapi/properties/properties.hpp> // for properties
+#include <sycl/ext/oneapi/properties.hpp> // for properties
 
 namespace sycl {
 inline namespace _V1 {
diff --git a/sycl/include/sycl/handler.hpp b/sycl/include/sycl/handler.hpp
index e3ab278570ff9..f6cd976c6284c 100644
--- a/sycl/include/sycl/handler.hpp
+++ b/sycl/include/sycl/handler.hpp
@@ -37,8 +37,8 @@
 #include <sycl/ext/oneapi/experimental/graph.hpp>
 #include <sycl/ext/oneapi/experimental/raw_kernel_arg.hpp>
 #include <sycl/ext/oneapi/experimental/use_root_sync_prop.hpp>
-#include <sycl/ext/oneapi/kernel_properties/properties.hpp>
-#include <sycl/ext/oneapi/properties/properties.hpp>
+#include <sycl/ext/oneapi/kernel_properties.hpp>
+#include <sycl/ext/oneapi/properties.hpp>
 #include <sycl/group.hpp>
 #include <sycl/id.hpp>
 #include <sycl/item.hpp>
diff --git a/sycl/include/sycl/kernel_bundle.hpp b/sycl/include/sycl/kernel_bundle.hpp
index 399781c8f2021..a37e45c0006a1 100644
--- a/sycl/include/sycl/kernel_bundle.hpp
+++ b/sycl/include/sycl/kernel_bundle.hpp
@@ -23,7 +23,7 @@
 #include <unified-runtime/ur_api.h>
 
 #include <sycl/ext/oneapi/experimental/free_function_traits.hpp>
-#include <sycl/ext/oneapi/properties/properties.hpp>     // PropertyT
+#include <sycl/ext/oneapi/properties.hpp>                // PropertyT
 #include <sycl/ext/oneapi/properties/property.hpp>       // build_options
 #include <sycl/ext/oneapi/properties/property_value.hpp> // and log
 
diff --git a/sycl/include/sycl/queue.hpp b/sycl/include/sycl/queue.hpp
index e2ca6b9e8786a..87304b7d1aaa5 100644
--- a/sycl/include/sycl/queue.hpp
+++ b/sycl/include/sycl/queue.hpp
@@ -34,7 +34,7 @@
 #include <sycl/ext/oneapi/device_global/properties.hpp> // for device_image_s...
 #include <sycl/ext/oneapi/experimental/event_mode_property.hpp>
 #include <sycl/ext/oneapi/experimental/graph.hpp>    // for command_graph...
-#include <sycl/ext/oneapi/properties/properties.hpp> // for empty_properti...
+#include <sycl/ext/oneapi/properties.hpp> // for empty_properti...
 #include <sycl/handler.hpp>                          // for handler, isDev...
 #include <sycl/id.hpp>                               // for id
 #include <sycl/kernel.hpp>                           // for auto_name
diff --git a/sycl/include/sycl/sycl.hpp b/sycl/include/sycl/sycl.hpp
index d9b8807ee5eb6..5fa296a108be7 100644
--- a/sycl/include/sycl/sycl.hpp
+++ b/sycl/include/sycl/sycl.hpp
@@ -136,11 +136,11 @@ can be disabled by setting SYCL_DISABLE_FSYCL_SYCLHPP_WARNING macro.")
 #include <sycl/ext/oneapi/functional.hpp>
 #include <sycl/ext/oneapi/get_kernel_info.hpp>
 #include <sycl/ext/oneapi/group_local_memory.hpp>
-#include <sycl/ext/oneapi/kernel_properties/properties.hpp>
+#include <sycl/ext/oneapi/kernel_properties.hpp>
 #include <sycl/ext/oneapi/matrix/matrix.hpp>
 #include <sycl/ext/oneapi/memcpy2d.hpp>
 #include <sycl/ext/oneapi/owner_less.hpp>
-#include <sycl/ext/oneapi/properties/properties.hpp>
+#include <sycl/ext/oneapi/properties.hpp>
 #include <sycl/ext/oneapi/properties/property_value.hpp>
 #include <sycl/ext/oneapi/sub_group.hpp>
 #include <sycl/ext/oneapi/sub_group_mask.hpp>
diff --git a/sycl/test-e2e/Graph/Update/FreeFunctionKernels/free_function_kernels.hpp b/sycl/test-e2e/Graph/Update/FreeFunctionKernels/free_function_kernels.hpp
index 3f595568876ae..16200bf564b2b 100644
--- a/sycl/test-e2e/Graph/Update/FreeFunctionKernels/free_function_kernels.hpp
+++ b/sycl/test-e2e/Graph/Update/FreeFunctionKernels/free_function_kernels.hpp
@@ -1,7 +1,7 @@
 #pragma once
 
 #include "../../graph_common.hpp"
-#include "sycl/ext/oneapi/kernel_properties/properties.hpp"
+#include "sycl/ext/oneapi/kernel_properties.hpp"
 #include "sycl/kernel_bundle.hpp"
 #include <sycl/ext/oneapi/free_function_queries.hpp>
 #include <sycl/group_barrier.hpp>
diff --git a/sycl/test-e2e/KernelCompiler/auto_pch_compile_error.cpp b/sycl/test-e2e/KernelCompiler/auto_pch_compile_error.cpp
index e59a478209bdf..27b6fd98b5ade 100644
--- a/sycl/test-e2e/KernelCompiler/auto_pch_compile_error.cpp
+++ b/sycl/test-e2e/KernelCompiler/auto_pch_compile_error.cpp
@@ -29,7 +29,7 @@ int main(int argc, char **argv) {
     std::string src = R"""(
 #include "non-existent.hpp"
 #include <sycl/ext/oneapi/free_function_queries.hpp>
-#include <sycl/ext/oneapi/kernel_properties/properties.hpp>
+#include <sycl/ext/oneapi/kernel_properties.hpp>
 
 namespace syclext = sycl::ext::oneapi;
 namespace syclexp = sycl::ext::oneapi::experimental;
diff --git a/sycl/test-e2e/KernelCompiler/auto_pch_time.cpp b/sycl/test-e2e/KernelCompiler/auto_pch_time.cpp
index 14557e4ff6d50..790999f8ac147 100644
--- a/sycl/test-e2e/KernelCompiler/auto_pch_time.cpp
+++ b/sycl/test-e2e/KernelCompiler/auto_pch_time.cpp
@@ -26,7 +26,7 @@ int main() {
 #include "a.hpp"
 #include <cstring>
 #include <sycl/ext/oneapi/free_function_queries.hpp>
-#include <sycl/ext/oneapi/kernel_properties/properties.hpp>
+#include <sycl/ext/oneapi/kernel_properties.hpp>
 namespace syclext = sycl::ext::oneapi;
 namespace syclexp = sycl::ext::oneapi::experimental;
 
diff --git a/sycl/test-e2e/KernelCompiler/conflicting_auto_pch_opts.cpp b/sycl/test-e2e/KernelCompiler/conflicting_auto_pch_opts.cpp
index 4e1e1856abc15..ec71cedace9db 100644
--- a/sycl/test-e2e/KernelCompiler/conflicting_auto_pch_opts.cpp
+++ b/sycl/test-e2e/KernelCompiler/conflicting_auto_pch_opts.cpp
@@ -21,7 +21,7 @@ int main(int argc, char **argv) {
   try {
     std::string src = R"""(
 #include <sycl/ext/oneapi/free_function_queries.hpp>
-#include <sycl/ext/oneapi/kernel_properties/properties.hpp>
+#include <sycl/ext/oneapi/kernel_properties.hpp>
 
 namespace syclext = sycl::ext::oneapi;
 namespace syclexp = sycl::ext::oneapi::experimental;
diff --git a/sycl/test-e2e/KernelCompiler/empty_preamble.cpp b/sycl/test-e2e/KernelCompiler/empty_preamble.cpp
index 5460557060656..9a3b91fec009b 100644
--- a/sycl/test-e2e/KernelCompiler/empty_preamble.cpp
+++ b/sycl/test-e2e/KernelCompiler/empty_preamble.cpp
@@ -22,7 +22,7 @@ namespace syclexp = sycl::ext::oneapi::experimental;
 int main(int argc, char **argv) {
   std::string src = R"""(void foo() {}
 #include <sycl/ext/oneapi/free_function_queries.hpp>
-#include <sycl/ext/oneapi/kernel_properties/properties.hpp>
+#include <sycl/ext/oneapi/kernel_properties.hpp>
 namespace syclext = sycl::ext::oneapi;
 namespace syclexp = sycl::ext::oneapi::experimental;
 
diff --git a/sycl/test-e2e/KernelCompiler/multi_threaded_rtc.cpp b/sycl/test-e2e/KernelCompiler/multi_threaded_rtc.cpp
index 3081f97056c1f..c790c169ab9ae 100644
--- a/sycl/test-e2e/KernelCompiler/multi_threaded_rtc.cpp
+++ b/sycl/test-e2e/KernelCompiler/multi_threaded_rtc.cpp
@@ -22,7 +22,7 @@ int main() {
   constexpr int N = 16;
   std::string src_str = R"""(
 #include <sycl/ext/oneapi/free_function_queries.hpp>
-#include <sycl/ext/oneapi/kernel_properties/properties.hpp>
+#include <sycl/ext/oneapi/kernel_properties.hpp>
 namespace syclext = sycl::ext::oneapi;
 namespace syclexp = sycl::ext::oneapi::experimental;
 
diff --git a/sycl/test-e2e/KernelCompiler/multiple_auto_pch_includes.cpp b/sycl/test-e2e/KernelCompiler/multiple_auto_pch_includes.cpp
index 5282d07dc56e8..c783528e67b81 100644
--- a/sycl/test-e2e/KernelCompiler/multiple_auto_pch_includes.cpp
+++ b/sycl/test-e2e/KernelCompiler/multiple_auto_pch_includes.cpp
@@ -47,7 +47,7 @@ int main(int argc, char **argv) {
 #include <sycl/builtins.hpp>
 #include <sycl/ext/oneapi/bfloat16.hpp>
 #include <sycl/ext/oneapi/free_function_queries.hpp>
-#include <sycl/ext/oneapi/kernel_properties/properties.hpp>
+#include <sycl/ext/oneapi/kernel_properties.hpp>
 #include <sycl/group_barrier.hpp>
 #include <sycl/half_type.hpp>
 #include <sycl/marray.hpp>
diff --git a/sycl/test-e2e/KernelCompiler/persistent_auto_pch_cache_collision.cpp b/sycl/test-e2e/KernelCompiler/persistent_auto_pch_cache_collision.cpp
index 568ce9509703a..5ca355cb99dba 100644
--- a/sycl/test-e2e/KernelCompiler/persistent_auto_pch_cache_collision.cpp
+++ b/sycl/test-e2e/KernelCompiler/persistent_auto_pch_cache_collision.cpp
@@ -44,7 +44,7 @@ std::string getInclude(int val) {
   return
       R"""(
 #include <sycl/ext/oneapi/free_function_queries.hpp>
-#include <sycl/ext/oneapi/kernel_properties/properties.hpp>
+#include <sycl/ext/oneapi/kernel_properties.hpp>
 inline constexpr int VAL = )""" +
       std::to_string(val) + ";\n";
 }
diff --git a/sycl/test-e2e/KernelCompiler/persistent_auto_pch_read_error.cpp b/sycl/test-e2e/KernelCompiler/persistent_auto_pch_read_error.cpp
index 4c94647141c9d..107d27c6b310d 100644
--- a/sycl/test-e2e/KernelCompiler/persistent_auto_pch_read_error.cpp
+++ b/sycl/test-e2e/KernelCompiler/persistent_auto_pch_read_error.cpp
@@ -31,7 +31,7 @@ namespace syclexp = sycl::ext::oneapi::experimental;
 
 const std::string src = R"""(
 #include <sycl/ext/oneapi/free_function_queries.hpp>
-#include <sycl/ext/oneapi/kernel_properties/properties.hpp>
+#include <sycl/ext/oneapi/kernel_properties.hpp>
 
 namespace syclext = sycl::ext::oneapi;
 namespace syclexp = sycl::ext::oneapi::experimental;
diff --git a/sycl/test-e2e/KernelCompiler/persistent_auto_pch_stress_deletion.cpp b/sycl/test-e2e/KernelCompiler/persistent_auto_pch_stress_deletion.cpp
index 2d6aa8a1c0a61..2fdb54941d50d 100644
--- a/sycl/test-e2e/KernelCompiler/persistent_auto_pch_stress_deletion.cpp
+++ b/sycl/test-e2e/KernelCompiler/persistent_auto_pch_stress_deletion.cpp
@@ -25,7 +25,7 @@ int main() {
   auto Run = [&](int i) {
     std::string preamble = R"""(
 #include <sycl/ext/oneapi/free_function_queries.hpp>
-#include <sycl/ext/oneapi/kernel_properties/properties.hpp>
+#include <sycl/ext/oneapi/kernel_properties.hpp>
 )""";
 
     std::string body = R"""(
diff --git a/sycl/test-e2e/KernelCompiler/preamble_define_before_include.cpp b/sycl/test-e2e/KernelCompiler/preamble_define_before_include.cpp
index af16cb0562557..ae1b3c718941c 100644
--- a/sycl/test-e2e/KernelCompiler/preamble_define_before_include.cpp
+++ b/sycl/test-e2e/KernelCompiler/preamble_define_before_include.cpp
@@ -38,7 +38,7 @@ int main(int argc, char **argv) {
   Test(R"""(
 #define SYCL_SIMPLE_SWIZZLES
 #include <sycl/ext/oneapi/free_function_queries.hpp>
-#include <sycl/ext/oneapi/kernel_properties/properties.hpp>
+#include <sycl/ext/oneapi/kernel_properties.hpp>
 #include <sycl/vector.hpp>
 
 namespace syclext = sycl::ext::oneapi;
diff --git a/sycl/test-e2e/KernelCompiler/preamble_if_stack.cpp b/sycl/test-e2e/KernelCompiler/preamble_if_stack.cpp
index 0029259dd8bcf..8b28526e16dc6 100644
--- a/sycl/test-e2e/KernelCompiler/preamble_if_stack.cpp
+++ b/sycl/test-e2e/KernelCompiler/preamble_if_stack.cpp
@@ -38,7 +38,7 @@ int main(int argc, char **argv) {
   Test(R"""(
 #if 1
 #include <sycl/ext/oneapi/free_function_queries.hpp>
-#include <sycl/ext/oneapi/kernel_properties/properties.hpp>
+#include <sycl/ext/oneapi/kernel_properties.hpp>
 namespace syclext = sycl::ext::oneapi;
 namespace syclexp = sycl::ext::oneapi::experimental;
 #else
@@ -58,7 +58,7 @@ void iota(float start, float *ptr) {
 fail_to_compile = 1;
 #else
 #include <sycl/ext/oneapi/free_function_queries.hpp>
-#include <sycl/ext/oneapi/kernel_properties/properties.hpp>
+#include <sycl/ext/oneapi/kernel_properties.hpp>
 namespace syclext = sycl::ext::oneapi;
 namespace syclexp = sycl::ext::oneapi::experimental;
 #endif
diff --git a/sycl/test-e2e/PerformanceTests/KernelCompiler/auto-pch.cpp b/sycl/test-e2e/PerformanceTests/KernelCompiler/auto-pch.cpp
index a9e7047d78dc0..9c9b893cda84c 100644
--- a/sycl/test-e2e/PerformanceTests/KernelCompiler/auto-pch.cpp
+++ b/sycl/test-e2e/PerformanceTests/KernelCompiler/auto-pch.cpp
@@ -23,7 +23,7 @@ void run(std::vector<std::string_view> ExtraHeaders) {
     // These are necessary:
     preamble << R"""(
 #include <sycl/ext/oneapi/free_function_queries.hpp>
-#include <sycl/ext/oneapi/kernel_properties/properties.hpp>
+#include <sycl/ext/oneapi/kernel_properties.hpp>
 )""";
 
     for (std::string_view Header : ExtraHeaders)
diff --git a/sycl/test/extensions/annotated_usm/invalid_usm_kind.cpp b/sycl/test/extensions/annotated_usm/invalid_usm_kind.cpp
index f9521d58d985e..fe2a050722c1b 100644
--- a/sycl/test/extensions/annotated_usm/invalid_usm_kind.cpp
+++ b/sycl/test/extensions/annotated_usm/invalid_usm_kind.cpp
@@ -94,7 +94,7 @@ void testConflictingUsmKind(sycl::queue &q) {
 
 // Duplicated properties (consistent or conflicting) exist in the property list
 void testInvalidPropList() {
-  // expected-error-re@sycl/ext/oneapi/properties/properties.hpp:* {{static assertion failed due to requirement {{.+}}: Duplicate properties in property list.}}
+  // expected-error-re@sycl/ext/oneapi/properties.hpp:* {{static assertion failed due to requirement {{.+}}: Duplicate properties in property list.}}
   properties InvalidPropList{usm_kind_device, usm_kind_host};
 }
 
diff --git a/sycl/test/extensions/properties/final_header_include_both.cpp b/sycl/test/extensions/properties/final_header_include_both.cpp
new file mode 100644
index 0000000000000..78215df980f56
--- /dev/null
+++ b/sycl/test/extensions/properties/final_header_include_both.cpp
@@ -0,0 +1,18 @@
+// RUN: %clangxx -fsycl -fsyntax-only -I %sycl_source_dir/include -I %sycl_include %s
+// expected-no-diagnostics
+
+#include <sycl/ext/oneapi/free_function_kernel_properties.hpp>
+#include <sycl/ext/oneapi/kernel_properties.hpp>
+#include <sycl/ext/oneapi/properties.hpp>
+
+#include <type_traits>
+
+using namespace sycl::ext::oneapi::experimental;
+
+int main() {
+  static_assert(is_property_value<decltype(single_task_kernel)>::value);
+  static_assert(is_property_value<decltype(work_group_size<2, 3>)>::value);
+  static_assert(std::is_same_v<decltype(properties{work_group_size<1>}),
+                               decltype(properties{work_group_size<1>})>);
+  return 0;
+}
\ No newline at end of file
diff --git a/sycl/test/extensions/properties/function_properties_split.cpp b/sycl/test/extensions/properties/function_properties_split.cpp
index e9891185d0725..35cf012cab71d 100644
--- a/sycl/test/extensions/properties/function_properties_split.cpp
+++ b/sycl/test/extensions/properties/function_properties_split.cpp
@@ -1,7 +1,7 @@
 // RUN: %clangxx -fsycl -fsycl-targets=%sycl_triple -fsyntax-only -I %sycl_source_dir/include -I %sycl_include %s
 // expected-no-diagnostics
 
-#include <sycl/ext/oneapi/kernel_properties/function_properties.hpp>
+#include <sycl/ext/oneapi/free_function_kernel_properties.hpp>
 
 #include <type_traits>
 
diff --git a/sycl/test/extensions/properties/kernel_function_properties_compat.cpp b/sycl/test/extensions/properties/kernel_function_properties_compat.cpp
new file mode 100644
index 0000000000000..ef0c5dc723e21
--- /dev/null
+++ b/sycl/test/extensions/properties/kernel_function_properties_compat.cpp
@@ -0,0 +1,20 @@
+// RUN: %clangxx -fsycl -fsycl-targets=%sycl_triple -fsyntax-only -I %sycl_source_dir/include -I %sycl_include %s
+// expected-no-diagnostics
+
+#include <sycl/ext/oneapi/kernel_properties/function_properties.hpp>
+
+#include <type_traits>
+
+using namespace sycl::ext::oneapi::experimental;
+
+int main() {
+  static_assert(is_property_value<decltype(nd_range_kernel<1>)>::value);
+  static_assert(is_property_value<decltype(single_task_kernel)>::value);
+  static_assert(is_property_value<decltype(work_group_size<2, 3>)>::value);
+  static_assert(std::is_same_v<decltype(max_linear_work_group_size<10>)::key_t,
+                               max_linear_work_group_size_key>);
+  static_assert(work_group_size<2, 3>[0] == 2);
+  static_assert(work_group_size<2, 3>[1] == 3);
+
+  return 0;
+}
\ No newline at end of file
diff --git a/sycl/test/extensions/properties/kernel_properties_compat.cpp b/sycl/test/extensions/properties/kernel_properties_compat.cpp
new file mode 100644
index 0000000000000..68d21a946ae47
--- /dev/null
+++ b/sycl/test/extensions/properties/kernel_properties_compat.cpp
@@ -0,0 +1,20 @@
+// RUN: %clangxx -fsycl -fsycl-targets=%sycl_triple -fsyntax-only -I %sycl_source_dir/include -I %sycl_include %s
+// expected-no-diagnostics
+
+#include <sycl/ext/oneapi/kernel_properties/properties.hpp>
+
+#include <type_traits>
+
+using namespace sycl::ext::oneapi::experimental;
+
+int main() {
+  constexpr auto Props = properties{work_group_size<2, 3>, device_has<sycl::aspect::cpu>};
+
+  static_assert(is_property_value<decltype(single_task_kernel)>::value);
+  static_assert(decltype(Props)::has_property<work_group_size_key>());
+  static_assert(decltype(Props)::has_property<device_has_key>());
+  static_assert(Props.get_property<work_group_size_key>()[0] == 2);
+  static_assert(Props.get_property<work_group_size_key>()[1] == 3);
+
+  return 0;
+}
\ No newline at end of file
diff --git a/sycl/test/extensions/properties/properties_ctor_negative.cpp b/sycl/test/extensions/properties/properties_ctor_negative.cpp
index e99e064944e39..4c9bad865a758 100644
--- a/sycl/test/extensions/properties/properties_ctor_negative.cpp
+++ b/sycl/test/extensions/properties/properties_ctor_negative.cpp
@@ -5,24 +5,24 @@
 #include "mock_compile_time_properties.hpp"
 
 int main() {
-  // expected-error-re@sycl/ext/oneapi/properties/properties.hpp:* {{static assertion failed due to requirement {{.+}} Non-property argument!}}
+    // expected-error-re@sycl/ext/oneapi/properties.hpp:* {{static assertion failed due to requirement {{.+}} Non-property argument!}}
   auto InvalidPropertyList1 = sycl::ext::oneapi::experimental::properties(1);
-  // expected-error-re@sycl/ext/oneapi/properties/properties.hpp:* {{static assertion failed due to requirement {{.+}} Non-property argument!}}
+    // expected-error-re@sycl/ext/oneapi/properties.hpp:* {{static assertion failed due to requirement {{.+}} Non-property argument!}}
   auto InvalidPropertyList2 = sycl::ext::oneapi::experimental::properties(
       sycl::ext::oneapi::experimental::foo{1}, true);
-  // expected-error-re@sycl/ext/oneapi/properties/properties.hpp:* {{static assertion failed due to requirement {{.+}}: Duplicate properties in property list.}}
+    // expected-error-re@sycl/ext/oneapi/properties.hpp:* {{static assertion failed due to requirement {{.+}}: Duplicate properties in property list.}}
   auto InvalidPropertyList3 = sycl::ext::oneapi::experimental::properties(
       sycl::ext::oneapi::experimental::foo{0},
       sycl::ext::oneapi::experimental::foo{1});
-  // expected-error-re@sycl/ext/oneapi/properties/properties.hpp:* {{static assertion failed due to requirement {{.+}}: Duplicate properties in property list.}}
+    // expected-error-re@sycl/ext/oneapi/properties.hpp:* {{static assertion failed due to requirement {{.+}}: Duplicate properties in property list.}}
   auto InvalidPropertyList4 = sycl::ext::oneapi::experimental::properties(
       sycl::ext::oneapi::experimental::bar,
       sycl::ext::oneapi::experimental::bar);
-  // expected-error-re@sycl/ext/oneapi/properties/properties.hpp:* {{static assertion failed due to requirement {{.+}}: Conflicting properties in property list.}}
+    // expected-error-re@sycl/ext/oneapi/properties.hpp:* {{static assertion failed due to requirement {{.+}}: Conflicting properties in property list.}}
   auto InvalidPropertyList5 = sycl::ext::oneapi::experimental::properties(
       sycl::ext::oneapi::experimental::boo<int>,
       sycl::ext::oneapi::experimental::fir(3.14, false));
-  // expected-error-re@sycl/ext/oneapi/properties/properties.hpp:* {{static assertion failed due to requirement {{.+}}: Conflicting properties in property list.}}
+    // expected-error-re@sycl/ext/oneapi/properties.hpp:* {{static assertion failed due to requirement {{.+}}: Conflicting properties in property list.}}
   auto InvalidPropertyList6 = sycl::ext::oneapi::experimental::properties(
       sycl::ext::oneapi::experimental::foo{0},
       sycl::ext::oneapi::experimental::boo<int>,
diff --git a/sycl/test/extensions/properties/properties_kernel_cache_config.cpp b/sycl/test/extensions/properties/properties_kernel_cache_config.cpp
index 8222bafddbe8b..040f3f1ed6fdb 100644
--- a/sycl/test/extensions/properties/properties_kernel_cache_config.cpp
+++ b/sycl/test/extensions/properties/properties_kernel_cache_config.cpp
@@ -27,7 +27,7 @@ int main() {
   assert(Props2.get_property<cache_config>() == large_data);
 
   // Check that duplicate cache_config can't be specified.
-  // expected-error-re@sycl/ext/oneapi/properties/properties.hpp:* {{static assertion failed due to requirement {{.+}}: Duplicate properties in property list.}}
+    // expected-error-re@sycl/ext/oneapi/properties.hpp:* {{static assertion failed due to requirement {{.+}}: Duplicate properties in property list.}}
   sycl::ext::oneapi::experimental::properties Props3(cache_config{large_data},
                                                      cache_config{large_slm});
 }
diff --git a/sycl/test/extensions/properties/properties_kernel_negative.cpp b/sycl/test/extensions/properties/properties_kernel_negative.cpp
index 3ee88369079fa..8dfdabc30bec1 100644
--- a/sycl/test/extensions/properties/properties_kernel_negative.cpp
+++ b/sycl/test/extensions/properties/properties_kernel_negative.cpp
@@ -30,129 +30,129 @@ void check_work_group_size() {
   // expected-error@+1 {{too few template arguments for variable template 'work_group_size'}}
   auto WGSize0 = sycl::ext::oneapi::experimental::work_group_size<>;
 
-  // expected-error-re@sycl/ext/oneapi/kernel_properties/function_properties.hpp:* {{static assertion failed due to requirement {{.+}}: work_group_size property must only contain non-zero values.}}
-  // expected-error@sycl/ext/oneapi/kernel_properties/function_properties.hpp:* {{constexpr variable 'work_group_size<0>' must be initialized by a constant expression}}
+    // expected-error-re@sycl/ext/oneapi/free_function_kernel_properties.hpp:* {{static assertion failed due to requirement {{.+}}: work_group_size property must only contain non-zero values.}}
+    // expected-error@sycl/ext/oneapi/free_function_kernel_properties.hpp:* {{constexpr variable 'work_group_size<0>' must be initialized by a constant expression}}
   // expected-note@+1 {{in instantiation of variable template specialization 'sycl::ext::oneapi::experimental::work_group_size<0>' requested here}}
   auto WGSize1 = sycl::ext::oneapi::experimental::work_group_size<0>;
-  // expected-error-re@sycl/ext/oneapi/kernel_properties/function_properties.hpp:* {{static assertion failed due to requirement {{.+}}: work_group_size property must only contain non-zero values.}}
-  // expected-error@sycl/ext/oneapi/kernel_properties/function_properties.hpp:* {{constexpr variable 'work_group_size<0, 0>' must be initialized by a constant expression}}
+    // expected-error-re@sycl/ext/oneapi/free_function_kernel_properties.hpp:* {{static assertion failed due to requirement {{.+}}: work_group_size property must only contain non-zero values.}}
+    // expected-error@sycl/ext/oneapi/free_function_kernel_properties.hpp:* {{constexpr variable 'work_group_size<0, 0>' must be initialized by a constant expression}}
   // expected-note@+1 {{in instantiation of variable template specialization 'sycl::ext::oneapi::experimental::work_group_size<0, 0>' requested here}}
   auto WGSize2 = sycl::ext::oneapi::experimental::work_group_size<0, 0>;
-  // expected-error-re@sycl/ext/oneapi/kernel_properties/function_properties.hpp:* {{static assertion failed due to requirement {{.+}}: work_group_size property must only contain non-zero values.}}
-  // expected-error@sycl/ext/oneapi/kernel_properties/function_properties.hpp:* {{constexpr variable 'work_group_size<1, 0>' must be initialized by a constant expression}}
+    // expected-error-re@sycl/ext/oneapi/free_function_kernel_properties.hpp:* {{static assertion failed due to requirement {{.+}}: work_group_size property must only contain non-zero values.}}
+    // expected-error@sycl/ext/oneapi/free_function_kernel_properties.hpp:* {{constexpr variable 'work_group_size<1, 0>' must be initialized by a constant expression}}
   // expected-note@+1 {{in instantiation of variable template specialization 'sycl::ext::oneapi::experimental::work_group_size<1, 0>' requested here}}
   auto WGSize3 = sycl::ext::oneapi::experimental::work_group_size<1, 0>;
-  // expected-error-re@sycl/ext/oneapi/kernel_properties/function_properties.hpp:* {{static assertion failed due to requirement {{.+}}: work_group_size property must only contain non-zero values.}}
-  // expected-error@sycl/ext/oneapi/kernel_properties/function_properties.hpp:* {{constexpr variable 'work_group_size<0, 1>' must be initialized by a constant expression}}
+    // expected-error-re@sycl/ext/oneapi/free_function_kernel_properties.hpp:* {{static assertion failed due to requirement {{.+}}: work_group_size property must only contain non-zero values.}}
+    // expected-error@sycl/ext/oneapi/free_function_kernel_properties.hpp:* {{constexpr variable 'work_group_size<0, 1>' must be initialized by a constant expression}}
   // expected-note@+1 {{in instantiation of variable template specialization 'sycl::ext::oneapi::experimental::work_group_size<0, 1>' requested here}}
   auto WGSize4 = sycl::ext::oneapi::experimental::work_group_size<0, 1>;
-  // expected-error-re@sycl/ext/oneapi/kernel_properties/function_properties.hpp:* {{static assertion failed due to requirement {{.+}}: work_group_size property must only contain non-zero values.}}
-  // expected-error@sycl/ext/oneapi/kernel_properties/function_properties.hpp:* {{constexpr variable 'work_group_size<0, 0, 0>' must be initialized by a constant expression}}
+    // expected-error-re@sycl/ext/oneapi/free_function_kernel_properties.hpp:* {{static assertion failed due to requirement {{.+}}: work_group_size property must only contain non-zero values.}}
+    // expected-error@sycl/ext/oneapi/free_function_kernel_properties.hpp:* {{constexpr variable 'work_group_size<0, 0, 0>' must be initialized by a constant expression}}
   // expected-note@+1 {{in instantiation of variable template specialization 'sycl::ext::oneapi::experimental::work_group_size<0, 0, 0>' requested here}}
   auto WGSize5 = sycl::ext::oneapi::experimental::work_group_size<0, 0, 0>;
-  // expected-error-re@sycl/ext/oneapi/kernel_properties/function_properties.hpp:* {{static assertion failed due to requirement {{.+}}: work_group_size property must only contain non-zero values.}}
-  // expected-error@sycl/ext/oneapi/kernel_properties/function_properties.hpp:* {{constexpr variable 'work_group_size<1, 0, 0>' must be initialized by a constant expression}}
+    // expected-error-re@sycl/ext/oneapi/free_function_kernel_properties.hpp:* {{static assertion failed due to requirement {{.+}}: work_group_size property must only contain non-zero values.}}
+    // expected-error@sycl/ext/oneapi/free_function_kernel_properties.hpp:* {{constexpr variable 'work_group_size<1, 0, 0>' must be initialized by a constant expression}}
   // expected-note@+1 {{in instantiation of variable template specialization 'sycl::ext::oneapi::experimental::work_group_size<1, 0, 0>' requested here}}
   auto WGSize6 = sycl::ext::oneapi::experimental::work_group_size<1, 0, 0>;
-  // expected-error-re@sycl/ext/oneapi/kernel_properties/function_properties.hpp:* {{static assertion failed due to requirement {{.+}}: work_group_size property must only contain non-zero values.}}
-  // expected-error@sycl/ext/oneapi/kernel_properties/function_properties.hpp:* {{constexpr variable 'work_group_size<0, 1, 0>' must be initialized by a constant expression}}
+    // expected-error-re@sycl/ext/oneapi/free_function_kernel_properties.hpp:* {{static assertion failed due to requirement {{.+}}: work_group_size property must only contain non-zero values.}}
+    // expected-error@sycl/ext/oneapi/free_function_kernel_properties.hpp:* {{constexpr variable 'work_group_size<0, 1, 0>' must be initialized by a constant expression}}
   // expected-note@+1 {{in instantiation of variable template specialization 'sycl::ext::oneapi::experimental::work_group_size<0, 1, 0>' requested here}}
   auto WGSize7 = sycl::ext::oneapi::experimental::work_group_size<0, 1, 0>;
-  // expected-error-re@sycl/ext/oneapi/kernel_properties/function_properties.hpp:* {{static assertion failed due to requirement {{.+}}: work_group_size property must only contain non-zero values.}}
-  // expected-error@sycl/ext/oneapi/kernel_properties/function_properties.hpp:* {{constexpr variable 'work_group_size<0, 0, 1>' must be initialized by a constant expression}}
+    // expected-error-re@sycl/ext/oneapi/free_function_kernel_properties.hpp:* {{static assertion failed due to requirement {{.+}}: work_group_size property must only contain non-zero values.}}
+    // expected-error@sycl/ext/oneapi/free_function_kernel_properties.hpp:* {{constexpr variable 'work_group_size<0, 0, 1>' must be initialized by a constant expression}}
   // expected-note@+1 {{in instantiation of variable template specialization 'sycl::ext::oneapi::experimental::work_group_size<0, 0, 1>' requested here}}
   auto WGSize8 = sycl::ext::oneapi::experimental::work_group_size<0, 0, 1>;
-  // expected-error-re@sycl/ext/oneapi/kernel_properties/function_properties.hpp:* {{static assertion failed due to requirement {{.+}}: work_group_size property must only contain non-zero values.}}
-  // expected-error@sycl/ext/oneapi/kernel_properties/function_properties.hpp:* {{constexpr variable 'work_group_size<1, 1, 0>' must be initialized by a constant expression}}
+    // expected-error-re@sycl/ext/oneapi/free_function_kernel_properties.hpp:* {{static assertion failed due to requirement {{.+}}: work_group_size property must only contain non-zero values.}}
+    // expected-error@sycl/ext/oneapi/free_function_kernel_properties.hpp:* {{constexpr variable 'work_group_size<1, 1, 0>' must be initialized by a constant expression}}
   // expected-note@+1 {{in instantiation of variable template specialization 'sycl::ext::oneapi::experimental::work_group_size<1, 1, 0>' requested here}}
   auto WGSize9 = sycl::ext::oneapi::experimental::work_group_size<1, 1, 0>;
-  // expected-error-re@sycl/ext/oneapi/kernel_properties/function_properties.hpp:* {{static assertion failed due to requirement {{.+}}: work_group_size property must only contain non-zero values.}}
-  // expected-error@sycl/ext/oneapi/kernel_properties/function_properties.hpp:* {{constexpr variable 'work_group_size<0, 1, 1>' must be initialized by a constant expression}}
+    // expected-error-re@sycl/ext/oneapi/free_function_kernel_properties.hpp:* {{static assertion failed due to requirement {{.+}}: work_group_size property must only contain non-zero values.}}
+    // expected-error@sycl/ext/oneapi/free_function_kernel_properties.hpp:* {{constexpr variable 'work_group_size<0, 1, 1>' must be initialized by a constant expression}}
   // expected-note@+1 {{in instantiation of variable template specialization 'sycl::ext::oneapi::experimental::work_group_size<0, 1, 1>' requested here}}
   auto WGSize10 = sycl::ext::oneapi::experimental::work_group_size<0, 1, 1>;
-  // expected-error-re@sycl/ext/oneapi/kernel_properties/function_properties.hpp:* {{static assertion failed due to requirement {{.+}}: work_group_size property must only contain non-zero values.}}
-  // expected-error@sycl/ext/oneapi/kernel_properties/function_properties.hpp:* {{constexpr variable 'work_group_size<1, 0, 1>' must be initialized by a constant expression}}
+    // expected-error-re@sycl/ext/oneapi/free_function_kernel_properties.hpp:* {{static assertion failed due to requirement {{.+}}: work_group_size property must only contain non-zero values.}}
+    // expected-error@sycl/ext/oneapi/free_function_kernel_properties.hpp:* {{constexpr variable 'work_group_size<1, 0, 1>' must be initialized by a constant expression}}
   // expected-note@+1 {{in instantiation of variable template specialization 'sycl::ext::oneapi::experimental::work_group_size<1, 0, 1>' requested here}}
   auto WGSize11 = sycl::ext::oneapi::experimental::work_group_size<1, 0, 1>;
 
-  // expected-error-re@sycl/ext/oneapi/kernel_properties/function_properties.hpp:* {{static assertion failed due to requirement {{.+}}: work_group_size property currently only supports up to three values.}}
-  // expected-error@sycl/ext/oneapi/kernel_properties/function_properties.hpp:* {{constexpr variable 'work_group_size<1, 1, 1, 1>' must be initialized by a constant expression}}
+    // expected-error-re@sycl/ext/oneapi/free_function_kernel_properties.hpp:* {{static assertion failed due to requirement {{.+}}: work_group_size property currently only supports up to three values.}}
+    // expected-error@sycl/ext/oneapi/free_function_kernel_properties.hpp:* {{constexpr variable 'work_group_size<1, 1, 1, 1>' must be initialized by a constant expression}}
   // expected-note@+1 {{in instantiation of variable template specialization 'sycl::ext::oneapi::experimental::work_group_size<1, 1, 1, 1>' requested here}}
   auto WGSize12 = sycl::ext::oneapi::experimental::work_group_size<1, 1, 1, 1>;
 
   sycl::queue Q;
 
-  // expected-error-re@sycl/ext/oneapi/properties/properties.hpp:* {{static assertion failed due to requirement {{.+}}: Failed to merge property lists due to conflicting properties.}}
+    // expected-error-re@sycl/ext/oneapi/properties.hpp:* {{static assertion failed due to requirement {{.+}}: Failed to merge property lists due to conflicting properties.}}
   // expected-note-re@+1 {{in instantiation of function template specialization {{.+}}}}
   Q.single_task(
       sycl::ext::oneapi::experimental::properties{
           sycl::ext::oneapi::experimental::work_group_size<1>},
       KernelFunctorWithWGSize<2>{});
 
-  // expected-error-re@sycl/ext/oneapi/properties/properties.hpp:* {{static assertion failed due to requirement {{.+}}: Failed to merge property lists due to conflicting properties.}}
+    // expected-error-re@sycl/ext/oneapi/properties.hpp:* {{static assertion failed due to requirement {{.+}}: Failed to merge property lists due to conflicting properties.}}
   // expected-note-re@+1 {{in instantiation of function template specialization {{.+}}}}
   Q.single_task(
       sycl::ext::oneapi::experimental::properties{
           sycl::ext::oneapi::experimental::work_group_size<1, 1>},
       KernelFunctorWithWGSize<1, 2>{});
 
-  // expected-error-re@sycl/ext/oneapi/properties/properties.hpp:* {{static assertion failed due to requirement {{.+}}: Failed to merge property lists due to conflicting properties.}}
+    // expected-error-re@sycl/ext/oneapi/properties.hpp:* {{static assertion failed due to requirement {{.+}}: Failed to merge property lists due to conflicting properties.}}
   // expected-note-re@+1 {{in instantiation of function template specialization {{.+}}}}
   Q.single_task(
       sycl::ext::oneapi::experimental::properties{
           sycl::ext::oneapi::experimental::work_group_size<1, 1>},
       KernelFunctorWithWGSize<2, 1>{});
 
-  // expected-error-re@sycl/ext/oneapi/properties/properties.hpp:* {{static assertion failed due to requirement {{.+}}: Failed to merge property lists due to conflicting properties.}}
+    // expected-error-re@sycl/ext/oneapi/properties.hpp:* {{static assertion failed due to requirement {{.+}}: Failed to merge property lists due to conflicting properties.}}
   // expected-note-re@+1 {{in instantiation of function template specialization {{.+}}}}
   Q.single_task(
       sycl::ext::oneapi::experimental::properties{
           sycl::ext::oneapi::experimental::work_group_size<1, 1>},
       KernelFunctorWithWGSize<2, 2>{});
 
-  // expected-error-re@sycl/ext/oneapi/properties/properties.hpp:* {{static assertion failed due to requirement {{.+}}: Failed to merge property lists due to conflicting properties.}}
+    // expected-error-re@sycl/ext/oneapi/properties.hpp:* {{static assertion failed due to requirement {{.+}}: Failed to merge property lists due to conflicting properties.}}
   // expected-note-re@+1 {{in instantiation of function template specialization {{.+}}}}
   Q.single_task(
       sycl::ext::oneapi::experimental::properties{
           sycl::ext::oneapi::experimental::work_group_size<1, 1, 1>},
       KernelFunctorWithWGSize<1, 1, 2>{});
 
-  // expected-error-re@sycl/ext/oneapi/properties/properties.hpp:* {{static assertion failed due to requirement {{.+}}: Failed to merge property lists due to conflicting properties.}}
+    // expected-error-re@sycl/ext/oneapi/properties.hpp:* {{static assertion failed due to requirement {{.+}}: Failed to merge property lists due to conflicting properties.}}
   // expected-note-re@+1 {{in instantiation of function template specialization {{.+}}}}
   Q.single_task(
       sycl::ext::oneapi::experimental::properties{
           sycl::ext::oneapi::experimental::work_group_size<1, 1, 1>},
       KernelFunctorWithWGSize<1, 2, 1>{});
 
-  // expected-error-re@sycl/ext/oneapi/properties/properties.hpp:* {{static assertion failed due to requirement {{.+}}: Failed to merge property lists due to conflicting properties.}}
+    // expected-error-re@sycl/ext/oneapi/properties.hpp:* {{static assertion failed due to requirement {{.+}}: Failed to merge property lists due to conflicting properties.}}
   // expected-note-re@+1 {{in instantiation of function template specialization {{.+}}}}
   Q.single_task(
       sycl::ext::oneapi::experimental::properties{
           sycl::ext::oneapi::experimental::work_group_size<1, 1, 1>},
       KernelFunctorWithWGSize<2, 1, 1>{});
 
-  // expected-error-re@sycl/ext/oneapi/properties/properties.hpp:* {{static assertion failed due to requirement {{.+}}: Failed to merge property lists due to conflicting properties.}}
+    // expected-error-re@sycl/ext/oneapi/properties.hpp:* {{static assertion failed due to requirement {{.+}}: Failed to merge property lists due to conflicting properties.}}
   // expected-note-re@+1 {{in instantiation of function template specialization {{.+}}}}
   Q.single_task(
       sycl::ext::oneapi::experimental::properties{
           sycl::ext::oneapi::experimental::work_group_size<1, 1, 1>},
       KernelFunctorWithWGSize<1, 2, 2>{});
 
-  // expected-error-re@sycl/ext/oneapi/properties/properties.hpp:* {{static assertion failed due to requirement {{.+}}: Failed to merge property lists due to conflicting properties.}}
+    // expected-error-re@sycl/ext/oneapi/properties.hpp:* {{static assertion failed due to requirement {{.+}}: Failed to merge property lists due to conflicting properties.}}
   // expected-note-re@+1 {{in instantiation of function template specialization {{.+}}}}
   Q.single_task(
       sycl::ext::oneapi::experimental::properties{
           sycl::ext::oneapi::experimental::work_group_size<1, 1, 1>},
       KernelFunctorWithWGSize<2, 2, 1>{});
 
-  // expected-error-re@sycl/ext/oneapi/properties/properties.hpp:* {{static assertion failed due to requirement {{.+}}: Failed to merge property lists due to conflicting properties.}}
+    // expected-error-re@sycl/ext/oneapi/properties.hpp:* {{static assertion failed due to requirement {{.+}}: Failed to merge property lists due to conflicting properties.}}
   // expected-note-re@+1 {{in instantiation of function template specialization {{.+}}}}
   Q.single_task(
       sycl::ext::oneapi::experimental::properties{
           sycl::ext::oneapi::experimental::work_group_size<1, 1, 1>},
       KernelFunctorWithWGSize<2, 1, 2>{});
 
-  // expected-error-re@sycl/ext/oneapi/properties/properties.hpp:* {{static assertion failed due to requirement {{.+}}: Failed to merge property lists due to conflicting properties.}}
+    // expected-error-re@sycl/ext/oneapi/properties.hpp:* {{static assertion failed due to requirement {{.+}}: Failed to merge property lists due to conflicting properties.}}
   // expected-note-re@+1 {{in instantiation of function template specialization {{.+}}}}
   Q.single_task(
       sycl::ext::oneapi::experimental::properties{
@@ -164,132 +164,132 @@ void check_work_group_size_hint() {
   // expected-error@+1 {{too few template arguments for variable template 'work_group_size_hint'}}
   auto WGSize0 = sycl::ext::oneapi::experimental::work_group_size_hint<>;
 
-  // expected-error-re@sycl/ext/oneapi/kernel_properties/function_properties.hpp:* {{static assertion failed due to requirement {{.+}}: work_group_size_hint property must only contain non-zero values.}}
-  // expected-error@sycl/ext/oneapi/kernel_properties/function_properties.hpp:* {{constexpr variable 'work_group_size_hint<0>' must be initialized by a constant expression}}
+    // expected-error-re@sycl/ext/oneapi/free_function_kernel_properties.hpp:* {{static assertion failed due to requirement {{.+}}: work_group_size_hint property must only contain non-zero values.}}
+    // expected-error@sycl/ext/oneapi/free_function_kernel_properties.hpp:* {{constexpr variable 'work_group_size_hint<0>' must be initialized by a constant expression}}
   // expected-note@+1 {{in instantiation of variable template specialization 'sycl::ext::oneapi::experimental::work_group_size_hint<0>' requested here}}
   auto WGSize1 = sycl::ext::oneapi::experimental::work_group_size_hint<0>;
-  // expected-error-re@sycl/ext/oneapi/kernel_properties/function_properties.hpp:* {{static assertion failed due to requirement {{.+}}: work_group_size_hint property must only contain non-zero values.}}
-  // expected-error@sycl/ext/oneapi/kernel_properties/function_properties.hpp:* {{constexpr variable 'work_group_size_hint<0, 0>' must be initialized by a constant expression}}
+    // expected-error-re@sycl/ext/oneapi/free_function_kernel_properties.hpp:* {{static assertion failed due to requirement {{.+}}: work_group_size_hint property must only contain non-zero values.}}
+    // expected-error@sycl/ext/oneapi/free_function_kernel_properties.hpp:* {{constexpr variable 'work_group_size_hint<0, 0>' must be initialized by a constant expression}}
   // expected-note@+1 {{in instantiation of variable template specialization 'sycl::ext::oneapi::experimental::work_group_size_hint<0, 0>' requested here}}
   auto WGSize2 = sycl::ext::oneapi::experimental::work_group_size_hint<0, 0>;
-  // expected-error-re@sycl/ext/oneapi/kernel_properties/function_properties.hpp:* {{static assertion failed due to requirement {{.+}}: work_group_size_hint property must only contain non-zero values.}}
-  // expected-error@sycl/ext/oneapi/kernel_properties/function_properties.hpp:* {{constexpr variable 'work_group_size_hint<1, 0>' must be initialized by a constant expression}}
+    // expected-error-re@sycl/ext/oneapi/free_function_kernel_properties.hpp:* {{static assertion failed due to requirement {{.+}}: work_group_size_hint property must only contain non-zero values.}}
+    // expected-error@sycl/ext/oneapi/free_function_kernel_properties.hpp:* {{constexpr variable 'work_group_size_hint<1, 0>' must be initialized by a constant expression}}
   // expected-note@+1 {{in instantiation of variable template specialization 'sycl::ext::oneapi::experimental::work_group_size_hint<1, 0>' requested here}}
   auto WGSize3 = sycl::ext::oneapi::experimental::work_group_size_hint<1, 0>;
-  // expected-error-re@sycl/ext/oneapi/kernel_properties/function_properties.hpp:* {{static assertion failed due to requirement {{.+}}: work_group_size_hint property must only contain non-zero values.}}
-  // expected-error@sycl/ext/oneapi/kernel_properties/function_properties.hpp:* {{constexpr variable 'work_group_size_hint<0, 1>' must be initialized by a constant expression}}
+    // expected-error-re@sycl/ext/oneapi/free_function_kernel_properties.hpp:* {{static assertion failed due to requirement {{.+}}: work_group_size_hint property must only contain non-zero values.}}
+    // expected-error@sycl/ext/oneapi/free_function_kernel_properties.hpp:* {{constexpr variable 'work_group_size_hint<0, 1>' must be initialized by a constant expression}}
   // expected-note@+1 {{in instantiation of variable template specialization 'sycl::ext::oneapi::experimental::work_group_size_hint<0, 1>' requested here}}
   auto WGSize4 = sycl::ext::oneapi::experimental::work_group_size_hint<0, 1>;
-  // expected-error-re@sycl/ext/oneapi/kernel_properties/function_properties.hpp:* {{static assertion failed due to requirement {{.+}}: work_group_size_hint property must only contain non-zero values.}}
-  // expected-error@sycl/ext/oneapi/kernel_properties/function_properties.hpp:* {{constexpr variable 'work_group_size_hint<0, 0, 0>' must be initialized by a constant expression}}
+    // expected-error-re@sycl/ext/oneapi/free_function_kernel_properties.hpp:* {{static assertion failed due to requirement {{.+}}: work_group_size_hint property must only contain non-zero values.}}
+    // expected-error@sycl/ext/oneapi/free_function_kernel_properties.hpp:* {{constexpr variable 'work_group_size_hint<0, 0, 0>' must be initialized by a constant expression}}
   // expected-note@+1 {{in instantiation of variable template specialization 'sycl::ext::oneapi::experimental::work_group_size_hint<0, 0, 0>' requested here}}
   auto WGSize5 = sycl::ext::oneapi::experimental::work_group_size_hint<0, 0, 0>;
-  // expected-error-re@sycl/ext/oneapi/kernel_properties/function_properties.hpp:* {{static assertion failed due to requirement {{.+}}: work_group_size_hint property must only contain non-zero values.}}
-  // expected-error@sycl/ext/oneapi/kernel_properties/function_properties.hpp:* {{constexpr variable 'work_group_size_hint<1, 0, 0>' must be initialized by a constant expression}}
+    // expected-error-re@sycl/ext/oneapi/free_function_kernel_properties.hpp:* {{static assertion failed due to requirement {{.+}}: work_group_size_hint property must only contain non-zero values.}}
+    // expected-error@sycl/ext/oneapi/free_function_kernel_properties.hpp:* {{constexpr variable 'work_group_size_hint<1, 0, 0>' must be initialized by a constant expression}}
   // expected-note@+1 {{in instantiation of variable template specialization 'sycl::ext::oneapi::experimental::work_group_size_hint<1, 0, 0>' requested here}}
   auto WGSize6 = sycl::ext::oneapi::experimental::work_group_size_hint<1, 0, 0>;
-  // expected-error-re@sycl/ext/oneapi/kernel_properties/function_properties.hpp:* {{static assertion failed due to requirement {{.+}}: work_group_size_hint property must only contain non-zero values.}}
-  // expected-error@sycl/ext/oneapi/kernel_properties/function_properties.hpp:* {{constexpr variable 'work_group_size_hint<0, 1, 0>' must be initialized by a constant expression}}
+    // expected-error-re@sycl/ext/oneapi/free_function_kernel_properties.hpp:* {{static assertion failed due to requirement {{.+}}: work_group_size_hint property must only contain non-zero values.}}
+    // expected-error@sycl/ext/oneapi/free_function_kernel_properties.hpp:* {{constexpr variable 'work_group_size_hint<0, 1, 0>' must be initialized by a constant expression}}
   // expected-note@+1 {{in instantiation of variable template specialization 'sycl::ext::oneapi::experimental::work_group_size_hint<0, 1, 0>' requested here}}
   auto WGSize7 = sycl::ext::oneapi::experimental::work_group_size_hint<0, 1, 0>;
-  // expected-error-re@sycl/ext/oneapi/kernel_properties/function_properties.hpp:* {{static assertion failed due to requirement {{.+}}: work_group_size_hint property must only contain non-zero values.}}
-  // expected-error@sycl/ext/oneapi/kernel_properties/function_properties.hpp:* {{constexpr variable 'work_group_size_hint<0, 0, 1>' must be initialized by a constant expression}}
+    // expected-error-re@sycl/ext/oneapi/free_function_kernel_properties.hpp:* {{static assertion failed due to requirement {{.+}}: work_group_size_hint property must only contain non-zero values.}}
+    // expected-error@sycl/ext/oneapi/free_function_kernel_properties.hpp:* {{constexpr variable 'work_group_size_hint<0, 0, 1>' must be initialized by a constant expression}}
   // expected-note@+1 {{in instantiation of variable template specialization 'sycl::ext::oneapi::experimental::work_group_size_hint<0, 0, 1>' requested here}}
   auto WGSize8 = sycl::ext::oneapi::experimental::work_group_size_hint<0, 0, 1>;
-  // expected-error-re@sycl/ext/oneapi/kernel_properties/function_properties.hpp:* {{static assertion failed due to requirement {{.+}}: work_group_size_hint property must only contain non-zero values.}}
-  // expected-error@sycl/ext/oneapi/kernel_properties/function_properties.hpp:* {{constexpr variable 'work_group_size_hint<1, 1, 0>' must be initialized by a constant expression}}
+    // expected-error-re@sycl/ext/oneapi/free_function_kernel_properties.hpp:* {{static assertion failed due to requirement {{.+}}: work_group_size_hint property must only contain non-zero values.}}
+    // expected-error@sycl/ext/oneapi/free_function_kernel_properties.hpp:* {{constexpr variable 'work_group_size_hint<1, 1, 0>' must be initialized by a constant expression}}
   // expected-note@+1 {{in instantiation of variable template specialization 'sycl::ext::oneapi::experimental::work_group_size_hint<1, 1, 0>' requested here}}
   auto WGSize9 = sycl::ext::oneapi::experimental::work_group_size_hint<1, 1, 0>;
-  // expected-error-re@sycl/ext/oneapi/kernel_properties/function_properties.hpp:* {{static assertion failed due to requirement {{.+}}: work_group_size_hint property must only contain non-zero values.}}
-  // expected-error@sycl/ext/oneapi/kernel_properties/function_properties.hpp:* {{constexpr variable 'work_group_size_hint<0, 1, 1>' must be initialized by a constant expression}}
+    // expected-error-re@sycl/ext/oneapi/free_function_kernel_properties.hpp:* {{static assertion failed due to requirement {{.+}}: work_group_size_hint property must only contain non-zero values.}}
+    // expected-error@sycl/ext/oneapi/free_function_kernel_properties.hpp:* {{constexpr variable 'work_group_size_hint<0, 1, 1>' must be initialized by a constant expression}}
   // expected-note@+2 {{in instantiation of variable template specialization 'sycl::ext::oneapi::experimental::work_group_size_hint<0, 1, 1>' requested here}}
   auto WGSize10 =
       sycl::ext::oneapi::experimental::work_group_size_hint<0, 1, 1>;
-  // expected-error-re@sycl/ext/oneapi/kernel_properties/function_properties.hpp:* {{static assertion failed due to requirement {{.+}}: work_group_size_hint property must only contain non-zero values.}}
-  // expected-error@sycl/ext/oneapi/kernel_properties/function_properties.hpp:* {{constexpr variable 'work_group_size_hint<1, 0, 1>' must be initialized by a constant expression}}
+    // expected-error-re@sycl/ext/oneapi/free_function_kernel_properties.hpp:* {{static assertion failed due to requirement {{.+}}: work_group_size_hint property must only contain non-zero values.}}
+    // expected-error@sycl/ext/oneapi/free_function_kernel_properties.hpp:* {{constexpr variable 'work_group_size_hint<1, 0, 1>' must be initialized by a constant expression}}
   // expected-note@+2 {{in instantiation of variable template specialization 'sycl::ext::oneapi::experimental::work_group_size_hint<1, 0, 1>' requested here}}
   auto WGSize11 =
       sycl::ext::oneapi::experimental::work_group_size_hint<1, 0, 1>;
 
-  // expected-error-re@sycl/ext/oneapi/kernel_properties/function_properties.hpp:* {{static assertion failed due to requirement {{.+}}: work_group_size_hint property currently only supports up to three values.}}
-  // expected-error@sycl/ext/oneapi/kernel_properties/function_properties.hpp:* {{constexpr variable 'work_group_size_hint<1, 1, 1, 1>' must be initialized by a constant expression}}
+    // expected-error-re@sycl/ext/oneapi/free_function_kernel_properties.hpp:* {{static assertion failed due to requirement {{.+}}: work_group_size_hint property currently only supports up to three values.}}
+    // expected-error@sycl/ext/oneapi/free_function_kernel_properties.hpp:* {{constexpr variable 'work_group_size_hint<1, 1, 1, 1>' must be initialized by a constant expression}}
   // expected-note@+2 {{in instantiation of variable template specialization 'sycl::ext::oneapi::experimental::work_group_size_hint<1, 1, 1, 1>' requested here}}
   auto WGSize12 =
       sycl::ext::oneapi::experimental::work_group_size_hint<1, 1, 1, 1>;
 
   sycl::queue Q;
 
-  // expected-error-re@sycl/ext/oneapi/properties/properties.hpp:* {{static assertion failed due to requirement {{.+}}: Failed to merge property lists due to conflicting properties.}}
+    // expected-error-re@sycl/ext/oneapi/properties.hpp:* {{static assertion failed due to requirement {{.+}}: Failed to merge property lists due to conflicting properties.}}
   // expected-note-re@+1 {{in instantiation of function template specialization {{.+}}}}
   Q.single_task(
       sycl::ext::oneapi::experimental::properties{
           sycl::ext::oneapi::experimental::work_group_size_hint<1>},
       KernelFunctorWithWGSizeHint<2>{});
 
-  // expected-error-re@sycl/ext/oneapi/properties/properties.hpp:* {{static assertion failed due to requirement {{.+}}: Failed to merge property lists due to conflicting properties.}}
+    // expected-error-re@sycl/ext/oneapi/properties.hpp:* {{static assertion failed due to requirement {{.+}}: Failed to merge property lists due to conflicting properties.}}
   // expected-note-re@+1 {{in instantiation of function template specialization {{.+}}}}
   Q.single_task(
       sycl::ext::oneapi::experimental::properties{
           sycl::ext::oneapi::experimental::work_group_size_hint<1, 1>},
       KernelFunctorWithWGSizeHint<1, 2>{});
 
-  // expected-error-re@sycl/ext/oneapi/properties/properties.hpp:* {{static assertion failed due to requirement {{.+}}: Failed to merge property lists due to conflicting properties.}}
+    // expected-error-re@sycl/ext/oneapi/properties.hpp:* {{static assertion failed due to requirement {{.+}}: Failed to merge property lists due to conflicting properties.}}
   // expected-note-re@+1 {{in instantiation of function template specialization {{.+}}}}
   Q.single_task(
       sycl::ext::oneapi::experimental::properties{
           sycl::ext::oneapi::experimental::work_group_size_hint<1, 1>},
       KernelFunctorWithWGSizeHint<2, 1>{});
 
-  // expected-error-re@sycl/ext/oneapi/properties/properties.hpp:* {{static assertion failed due to requirement {{.+}}: Failed to merge property lists due to conflicting properties.}}
+    // expected-error-re@sycl/ext/oneapi/properties.hpp:* {{static assertion failed due to requirement {{.+}}: Failed to merge property lists due to conflicting properties.}}
   // expected-note-re@+1 {{in instantiation of function template specialization {{.+}}}}
   Q.single_task(
       sycl::ext::oneapi::experimental::properties{
           sycl::ext::oneapi::experimental::work_group_size_hint<1, 1>},
       KernelFunctorWithWGSizeHint<2, 2>{});
 
-  // expected-error-re@sycl/ext/oneapi/properties/properties.hpp:* {{static assertion failed due to requirement {{.+}}: Failed to merge property lists due to conflicting properties.}}
+    // expected-error-re@sycl/ext/oneapi/properties.hpp:* {{static assertion failed due to requirement {{.+}}: Failed to merge property lists due to conflicting properties.}}
   // expected-note-re@+1 {{in instantiation of function template specialization {{.+}}}}
   Q.single_task(
       sycl::ext::oneapi::experimental::properties{
           sycl::ext::oneapi::experimental::work_group_size_hint<1, 1, 1>},
       KernelFunctorWithWGSizeHint<1, 1, 2>{});
 
-  // expected-error-re@sycl/ext/oneapi/properties/properties.hpp:* {{static assertion failed due to requirement {{.+}}: Failed to merge property lists due to conflicting properties.}}
+  // expected-error-re@sycl/ext/oneapi/properties.hpp:* {{static assertion failed due to requirement {{.+}}: Failed to merge property lists due to conflicting properties.}}
   // expected-note-re@+1 {{in instantiation of function template specialization {{.+}}}}
   Q.single_task(
       sycl::ext::oneapi::experimental::properties{
           sycl::ext::oneapi::experimental::work_group_size_hint<1, 1, 1>},
       KernelFunctorWithWGSizeHint<1, 2, 1>{});
 
-  // expected-error-re@sycl/ext/oneapi/properties/properties.hpp:* {{static assertion failed due to requirement {{.+}}: Failed to merge property lists due to conflicting properties.}}
+  // expected-error-re@sycl/ext/oneapi/properties.hpp:* {{static assertion failed due to requirement {{.+}}: Failed to merge property lists due to conflicting properties.}}
   // expected-note-re@+1 {{in instantiation of function template specialization {{.+}}}}
   Q.single_task(
       sycl::ext::oneapi::experimental::properties{
           sycl::ext::oneapi::experimental::work_group_size_hint<1, 1, 1>},
       KernelFunctorWithWGSizeHint<2, 1, 1>{});
 
-  // expected-error-re@sycl/ext/oneapi/properties/properties.hpp:* {{static assertion failed due to requirement {{.+}}: Failed to merge property lists due to conflicting properties.}}
+  // expected-error-re@sycl/ext/oneapi/properties.hpp:* {{static assertion failed due to requirement {{.+}}: Failed to merge property lists due to conflicting properties.}}
   // expected-note-re@+1 {{in instantiation of function template specialization {{.+}}}}
   Q.single_task(
       sycl::ext::oneapi::experimental::properties{
           sycl::ext::oneapi::experimental::work_group_size_hint<1, 1, 1>},
       KernelFunctorWithWGSizeHint<1, 2, 2>{});
 
-  // expected-error-re@sycl/ext/oneapi/properties/properties.hpp:* {{static assertion failed due to requirement {{.+}}: Failed to merge property lists due to conflicting properties.}}
+  // expected-error-re@sycl/ext/oneapi/properties.hpp:* {{static assertion failed due to requirement {{.+}}: Failed to merge property lists due to conflicting properties.}}
   // expected-note-re@+1 {{in instantiation of function template specialization {{.+}}}}
   Q.single_task(
       sycl::ext::oneapi::experimental::properties{
           sycl::ext::oneapi::experimental::work_group_size_hint<1, 1, 1>},
       KernelFunctorWithWGSizeHint<2, 2, 1>{});
 
-  // expected-error-re@sycl/ext/oneapi/properties/properties.hpp:* {{static assertion failed due to requirement {{.+}}: Failed to merge property lists due to conflicting properties.}}
+  // expected-error-re@sycl/ext/oneapi/properties.hpp:* {{static assertion failed due to requirement {{.+}}: Failed to merge property lists due to conflicting properties.}}
   // expected-note-re@+1 {{in instantiation of function template specialization {{.+}}}}
   Q.single_task(
       sycl::ext::oneapi::experimental::properties{
           sycl::ext::oneapi::experimental::work_group_size_hint<1, 1, 1>},
       KernelFunctorWithWGSizeHint<2, 1, 2>{});
 
-  // expected-error-re@sycl/ext/oneapi/properties/properties.hpp:* {{static assertion failed due to requirement {{.+}}: Failed to merge property lists due to conflicting properties.}}
+  // expected-error-re@sycl/ext/oneapi/properties.hpp:* {{static assertion failed due to requirement {{.+}}: Failed to merge property lists due to conflicting properties.}}
   // expected-note-re@+1 {{in instantiation of function template specialization {{.+}}}}
   Q.single_task(
       sycl::ext::oneapi::experimental::properties{
@@ -301,14 +301,14 @@ void check_sub_group_size() {
   // expected-error@+1 {{too few template arguments for variable template 'sub_group_size'}}
   auto WGSize0 = sycl::ext::oneapi::experimental::sub_group_size<>;
 
-  // expected-error-re@sycl/ext/oneapi/kernel_properties/function_properties.hpp:* {{static assertion failed due to requirement {{.+}}: sub_group_size property must contain a non-zero value.}}
-  // expected-error@sycl/ext/oneapi/kernel_properties/function_properties.hpp:* {{constexpr variable 'sub_group_size<0>' must be initialized by a constant expression}}
+    // expected-error-re@sycl/ext/oneapi/free_function_kernel_properties.hpp:* {{static assertion failed due to requirement {{.+}}: sub_group_size property must contain a non-zero value.}}
+    // expected-error@sycl/ext/oneapi/free_function_kernel_properties.hpp:* {{constexpr variable 'sub_group_size<0>' must be initialized by a constant expression}}
   // expected-note@+1 {{in instantiation of variable template specialization 'sycl::ext::oneapi::experimental::sub_group_size<0>' requested here}}
   auto WGSize1 = sycl::ext::oneapi::experimental::sub_group_size<0>;
 
   sycl::queue Q;
 
-  // expected-error-re@sycl/ext/oneapi/properties/properties.hpp:* {{static assertion failed due to requirement {{.+}}: Failed to merge property lists due to conflicting properties.}}
+    // expected-error-re@sycl/ext/oneapi/properties.hpp:* {{static assertion failed due to requirement {{.+}}: Failed to merge property lists due to conflicting properties.}}
   // expected-note-re@+1 {{in instantiation of function template specialization {{.+}}}}
   Q.single_task(
       sycl::ext::oneapi::experimental::properties{
@@ -319,28 +319,28 @@ void check_sub_group_size() {
 void check_max_work_group_size() {
   sycl::queue Q;
 
-  // expected-error-re@sycl/ext/oneapi/kernel_properties/properties.hpp:* {{static assertion failed due to requirement {{.+}}: work_group_size and max_work_group_size dimensionality must match}}
+    // expected-error-re@sycl/detail/kernel_launch_helper.hpp:* {{static assertion failed due to requirement {{.+}}: work_group_size and max_work_group_size dimensionality must match}}
   Q.single_task(
       sycl::ext::oneapi::experimental::properties{
           sycl::ext::oneapi::experimental::work_group_size<2, 2>,
           sycl::ext::oneapi::experimental::max_work_group_size<1>},
       []() {});
 
-  // expected-error-re@sycl/ext/oneapi/kernel_properties/properties.hpp:* {{static assertion failed due to requirement {{.+}}: work_group_size must not exceed max_work_group_size}}
+    // expected-error-re@sycl/detail/kernel_launch_helper.hpp:* {{static assertion failed due to requirement {{.+}}: work_group_size must not exceed max_work_group_size}}
   Q.single_task(
       sycl::ext::oneapi::experimental::properties{
           sycl::ext::oneapi::experimental::work_group_size<2>,
           sycl::ext::oneapi::experimental::max_work_group_size<1>},
       []() {});
 
-  // expected-error-re@sycl/ext/oneapi/kernel_properties/properties.hpp:* {{static assertion failed due to requirement {{.+}}: work_group_size must not exceed max_work_group_size}}
+    // expected-error-re@sycl/detail/kernel_launch_helper.hpp:* {{static assertion failed due to requirement {{.+}}: work_group_size must not exceed max_work_group_size}}
   Q.single_task(
       sycl::ext::oneapi::experimental::properties{
           sycl::ext::oneapi::experimental::work_group_size<2, 2>,
           sycl::ext::oneapi::experimental::max_work_group_size<2, 1>},
       []() {});
 
-  // expected-error-re@sycl/ext/oneapi/kernel_properties/properties.hpp:* {{static assertion failed due to requirement {{.+}}: work_group_size must not exceed max_work_group_size}}
+    // expected-error-re@sycl/detail/kernel_launch_helper.hpp:* {{static assertion failed due to requirement {{.+}}: work_group_size must not exceed max_work_group_size}}
   Q.single_task(
       sycl::ext::oneapi::experimental::properties{
           sycl::ext::oneapi::experimental::work_group_size<2, 2, 2>,
@@ -351,21 +351,21 @@ void check_max_work_group_size() {
 void check_max_linear_work_group_size() {
   sycl::queue Q;
 
-  // expected-error-re@sycl/ext/oneapi/kernel_properties/properties.hpp:* {{static assertion failed due to requirement {{.+}}: work_group_size must not exceed max_linear_work_group_size}}
+    // expected-error-re@sycl/detail/kernel_launch_helper.hpp:* {{static assertion failed due to requirement {{.+}}: work_group_size must not exceed max_linear_work_group_size}}
   Q.single_task(
       sycl::ext::oneapi::experimental::properties{
           sycl::ext::oneapi::experimental::work_group_size<2>,
           sycl::ext::oneapi::experimental::max_linear_work_group_size<1>},
       []() {});
 
-  // expected-error-re@sycl/ext/oneapi/kernel_properties/properties.hpp:* {{static assertion failed due to requirement {{.+}}: work_group_size must not exceed max_linear_work_group_size}}
+    // expected-error-re@sycl/detail/kernel_launch_helper.hpp:* {{static assertion failed due to requirement {{.+}}: work_group_size must not exceed max_linear_work_group_size}}
   Q.single_task(
       sycl::ext::oneapi::experimental::properties{
           sycl::ext::oneapi::experimental::work_group_size<2, 4>,
           sycl::ext::oneapi::experimental::max_linear_work_group_size<7>},
       []() {});
 
-  // expected-error-re@sycl/ext/oneapi/kernel_properties/properties.hpp:* {{static assertion failed due to requirement {{.+}}: work_group_size must not exceed max_linear_work_group_size}}
+    // expected-error-re@sycl/detail/kernel_launch_helper.hpp:* {{static assertion failed due to requirement {{.+}}: work_group_size must not exceed max_linear_work_group_size}}
   Q.single_task(
       sycl::ext::oneapi::experimental::properties{
           sycl::ext::oneapi::experimental::work_group_size<2, 4, 2>,
diff --git a/sycl/test/include_deps/sycl_detail_core.hpp.cpp b/sycl/test/include_deps/sycl_detail_core.hpp.cpp
index 72d93643164a2..bbaba999e6a04 100644
--- a/sycl/test/include_deps/sycl_detail_core.hpp.cpp
+++ b/sycl/test/include_deps/sycl_detail_core.hpp.cpp
@@ -112,11 +112,11 @@
 // CHECK-NEXT: detail/util.hpp
 // CHECK-NEXT: device_selector.hpp
 // CHECK-NEXT: kernel_bundle_enums.hpp
-// CHECK-NEXT: ext/oneapi/kernel_properties/properties.hpp
-// CHECK-NEXT: ext/oneapi/kernel_properties/function_properties.hpp
+// CHECK-NEXT: ext/oneapi/kernel_properties.hpp
+// CHECK-NEXT: ext/oneapi/free_function_kernel_properties.hpp
 // CHECK-NEXT: ext/oneapi/properties/property_value.hpp
 // CHECK-NEXT: ext/oneapi/properties/property.hpp
-// CHECK-NEXT: ext/oneapi/properties/properties.hpp
+// CHECK-NEXT: ext/oneapi/properties.hpp
 // CHECK-NEXT: ext/oneapi/properties/property_utils.hpp
 // CHECK-NEXT: event.hpp
 // CHECK-NEXT: exception_list.hpp
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 7f19980446c7d..2607932e0178d 100644
--- a/sycl/test/include_deps/sycl_khr_includes_handler.hpp.cpp
+++ b/sycl/test/include_deps/sycl_khr_includes_handler.hpp.cpp
@@ -120,7 +120,7 @@
 // CHECK-NEXT: ext/oneapi/properties/property_value.hpp
 // CHECK-NEXT: ext/intel/experimental/kernel_execution_properties.hpp
 // CHECK-NEXT: ext/oneapi/experimental/cluster_group_prop.hpp
-// CHECK-NEXT: ext/oneapi/properties/properties.hpp
+// CHECK-NEXT: ext/oneapi/properties.hpp
 // CHECK-NEXT: ext/oneapi/properties/property_utils.hpp
 // CHECK-NEXT: ext/oneapi/experimental/graph.hpp
 // CHECK-NEXT: ext/oneapi/experimental/graph/command_graph.hpp
@@ -135,8 +135,8 @@
 // CHECK-NEXT: ext/oneapi/experimental/work_group_memory.hpp
 // CHECK-NEXT: ext/oneapi/experimental/use_root_sync_prop.hpp
 // CHECK-NEXT: ext/oneapi/experimental/virtual_functions.hpp
-// CHECK-NEXT: ext/oneapi/kernel_properties/function_properties.hpp
-// CHECK-NEXT: ext/oneapi/kernel_properties/properties.hpp
+// CHECK-NEXT: ext/oneapi/free_function_kernel_properties.hpp
+// CHECK-NEXT: ext/oneapi/kernel_properties.hpp
 // CHECK-NEXT: ext/oneapi/work_group_scratch_memory.hpp
 // CHECK-NEXT: detail/sycl_local_mem_builtins.hpp
 // CHECK-NEXT: detail/nd_range_view.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 eacb3c8070d1c..aa10fb3269159 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
@@ -107,7 +107,7 @@
 // CHECK-NEXT: ext/oneapi/experimental/graph/dynamic.hpp
 // CHECK-NEXT: detail/kernel_desc.hpp
 // CHECK-NEXT: ext/oneapi/experimental/work_group_memory.hpp
-// CHECK-NEXT: ext/oneapi/properties/properties.hpp
+// CHECK-NEXT: ext/oneapi/properties.hpp
 // CHECK-NEXT: ext/oneapi/properties/property_utils.hpp
 // CHECK-NEXT: ext/oneapi/properties/property.hpp
 // CHECK-NEXT: ext/oneapi/properties/property_value.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 4e7588112ff91..54d046178732f 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
@@ -128,7 +128,7 @@
 // CHECK-NEXT: ext/oneapi/properties/property_value.hpp
 // CHECK-NEXT: ext/intel/experimental/kernel_execution_properties.hpp
 // CHECK-NEXT: ext/oneapi/experimental/cluster_group_prop.hpp
-// CHECK-NEXT: ext/oneapi/properties/properties.hpp
+// CHECK-NEXT: ext/oneapi/properties.hpp
 // CHECK-NEXT: ext/oneapi/properties/property_utils.hpp
 // CHECK-NEXT: ext/oneapi/experimental/graph.hpp
 // CHECK-NEXT: ext/oneapi/experimental/graph/command_graph.hpp
@@ -143,8 +143,8 @@
 // CHECK-NEXT: ext/oneapi/experimental/work_group_memory.hpp
 // CHECK-NEXT: ext/oneapi/experimental/use_root_sync_prop.hpp
 // CHECK-NEXT: ext/oneapi/experimental/virtual_functions.hpp
-// CHECK-NEXT: ext/oneapi/kernel_properties/function_properties.hpp
-// CHECK-NEXT: ext/oneapi/kernel_properties/properties.hpp
+// CHECK-NEXT: ext/oneapi/free_function_kernel_properties.hpp
+// CHECK-NEXT: ext/oneapi/kernel_properties.hpp
 // CHECK-NEXT: ext/oneapi/work_group_scratch_memory.hpp
 // CHECK-NEXT: detail/sycl_local_mem_builtins.hpp
 // CHECK-NEXT: detail/nd_range_view.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 954e8906be1de..b30bfd90e0de8 100644
--- a/sycl/test/include_deps/sycl_khr_includes_queue.hpp.cpp
+++ b/sycl/test/include_deps/sycl_khr_includes_queue.hpp.cpp
@@ -116,11 +116,11 @@
 // CHECK-NEXT: detail/util.hpp
 // CHECK-NEXT: device_selector.hpp
 // CHECK-NEXT: kernel_bundle_enums.hpp
-// CHECK-NEXT: ext/oneapi/kernel_properties/properties.hpp
-// CHECK-NEXT: ext/oneapi/kernel_properties/function_properties.hpp
+// CHECK-NEXT: ext/oneapi/kernel_properties.hpp
+// CHECK-NEXT: ext/oneapi/free_function_kernel_properties.hpp
 // CHECK-NEXT: ext/oneapi/properties/property_value.hpp
 // CHECK-NEXT: ext/oneapi/properties/property.hpp
-// CHECK-NEXT: ext/oneapi/properties/properties.hpp
+// CHECK-NEXT: ext/oneapi/properties.hpp
 // CHECK-NEXT: ext/oneapi/properties/property_utils.hpp
 // CHECK-NEXT: event.hpp
 // CHECK-NEXT: exception_list.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 a3db1523e08d5..966849bbedb90 100644
--- a/sycl/test/include_deps/sycl_khr_includes_reduction.hpp.cpp
+++ b/sycl/test/include_deps/sycl_khr_includes_reduction.hpp.cpp
@@ -157,7 +157,7 @@
 // CHECK-NEXT: ext/oneapi/properties/property_value.hpp
 // CHECK-NEXT: ext/intel/experimental/kernel_execution_properties.hpp
 // CHECK-NEXT: ext/oneapi/experimental/cluster_group_prop.hpp
-// CHECK-NEXT: ext/oneapi/properties/properties.hpp
+// CHECK-NEXT: ext/oneapi/properties.hpp
 // CHECK-NEXT: ext/oneapi/properties/property_utils.hpp
 // CHECK-NEXT: ext/oneapi/experimental/graph.hpp
 // CHECK-NEXT: ext/oneapi/experimental/graph/command_graph.hpp
@@ -172,8 +172,8 @@
 // CHECK-NEXT: ext/oneapi/experimental/work_group_memory.hpp
 // CHECK-NEXT: ext/oneapi/experimental/use_root_sync_prop.hpp
 // CHECK-NEXT: ext/oneapi/experimental/virtual_functions.hpp
-// CHECK-NEXT: ext/oneapi/kernel_properties/function_properties.hpp
-// CHECK-NEXT: ext/oneapi/kernel_properties/properties.hpp
+// CHECK-NEXT: ext/oneapi/free_function_kernel_properties.hpp
+// CHECK-NEXT: ext/oneapi/kernel_properties.hpp
 // CHECK-NEXT: ext/oneapi/work_group_scratch_memory.hpp
 // CHECK-NEXT: detail/sycl_local_mem_builtins.hpp
 // CHECK-NEXT: detail/nd_range_view.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 166c8c70a4299..3e9d522a7ca5a 100644
--- a/sycl/test/include_deps/sycl_khr_includes_stream.hpp.cpp
+++ b/sycl/test/include_deps/sycl_khr_includes_stream.hpp.cpp
@@ -138,7 +138,7 @@
 // CHECK-NEXT: ext/oneapi/properties/property_value.hpp
 // CHECK-NEXT: ext/intel/experimental/kernel_execution_properties.hpp
 // CHECK-NEXT: ext/oneapi/experimental/cluster_group_prop.hpp
-// CHECK-NEXT: ext/oneapi/properties/properties.hpp
+// CHECK-NEXT: ext/oneapi/properties.hpp
 // CHECK-NEXT: ext/oneapi/properties/property_utils.hpp
 // CHECK-NEXT: ext/oneapi/experimental/graph.hpp
 // CHECK-NEXT: ext/oneapi/experimental/graph/command_graph.hpp
@@ -153,8 +153,8 @@
 // CHECK-NEXT: ext/oneapi/experimental/work_group_memory.hpp
 // CHECK-NEXT: ext/oneapi/experimental/use_root_sync_prop.hpp
 // CHECK-NEXT: ext/oneapi/experimental/virtual_functions.hpp
-// CHECK-NEXT: ext/oneapi/kernel_properties/function_properties.hpp
-// CHECK-NEXT: ext/oneapi/kernel_properties/properties.hpp
+// CHECK-NEXT: ext/oneapi/free_function_kernel_properties.hpp
+// CHECK-NEXT: ext/oneapi/kernel_properties.hpp
 // CHECK-NEXT: ext/oneapi/work_group_scratch_memory.hpp
 // CHECK-NEXT: detail/sycl_local_mem_builtins.hpp
 // CHECK-NEXT: detail/nd_range_view.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 1478ac6895dc8..3f001389677a2 100644
--- a/sycl/test/include_deps/sycl_khr_includes_usm.hpp.cpp
+++ b/sycl/test/include_deps/sycl_khr_includes_usm.hpp.cpp
@@ -131,11 +131,11 @@
 // CHECK-NEXT: detail/nd_range_view.hpp
 // CHECK-NEXT: detail/optional.hpp
 // CHECK-NEXT: detail/range_rounding.hpp
-// CHECK-NEXT: ext/oneapi/kernel_properties/properties.hpp
-// CHECK-NEXT: ext/oneapi/kernel_properties/function_properties.hpp
+// CHECK-NEXT: ext/oneapi/kernel_properties.hpp
+// CHECK-NEXT: ext/oneapi/free_function_kernel_properties.hpp
 // CHECK-NEXT: ext/oneapi/properties/property_value.hpp
 // CHECK-NEXT: ext/oneapi/properties/property.hpp
-// CHECK-NEXT: ext/oneapi/properties/properties.hpp
+// CHECK-NEXT: ext/oneapi/properties.hpp
 // CHECK-NEXT: ext/oneapi/properties/property_utils.hpp
 // CHECK-NEXT: event.hpp
 // CHECK-NEXT: exception_list.hpp

From 206485dad6f5eba8c0621a871dda21c7861dc46e Mon Sep 17 00:00:00 2001
From: y <konstantinos.parasyris@intel.com>
Date: Thu, 23 Apr 2026 10:50:10 -0700
Subject: [PATCH 05/11] Format

---
 .../sycl/detail/kernel_launch_helper.hpp      |  26 +-
 .../free_function_kernel_properties.hpp       | 382 ++++++-------
 .../sycl/ext/oneapi/kernel_properties.hpp     | 186 +++---
 sycl/include/sycl/ext/oneapi/properties.hpp   | 536 +++++++++---------
 .../ext/oneapi/work_group_scratch_memory.hpp  |   2 +-
 sycl/include/sycl/queue.hpp                   |   2 +-
 .../properties/kernel_properties_compat.cpp   |   3 +-
 .../properties/properties_ctor_negative.cpp   |  12 +-
 .../properties_kernel_cache_config.cpp        |   2 +-
 .../properties/properties_kernel_negative.cpp | 148 ++---
 10 files changed, 647 insertions(+), 652 deletions(-)

diff --git a/sycl/include/sycl/detail/kernel_launch_helper.hpp b/sycl/include/sycl/detail/kernel_launch_helper.hpp
index 3aff73e58130d..f9f1f31462bee 100644
--- a/sycl/include/sycl/detail/kernel_launch_helper.hpp
+++ b/sycl/include/sycl/detail/kernel_launch_helper.hpp
@@ -361,15 +361,15 @@ using KernelPropertyHolderStructTy =
                 sycl::ext::oneapi::experimental::cuda::cluster_size_key<2>,
                 sycl::ext::oneapi::experimental::cuda::cluster_size_key<3>>;
 
-template <typename PropertiesT>
-constexpr void validateKernelProperties() {
+template <typename PropertiesT> constexpr void validateKernelProperties() {
   using namespace sycl::ext::oneapi::experimental;
 
   if constexpr (PropertiesT::template has_property<work_group_size_key>()) {
     constexpr auto WGSize =
         PropertiesT::template get_property<work_group_size_key>();
 
-    if constexpr (PropertiesT::template has_property<max_work_group_size_key>()) {
+    if constexpr (PropertiesT::template has_property<
+                      max_work_group_size_key>()) {
       constexpr auto MaxWGSize =
           PropertiesT::template get_property<max_work_group_size_key>();
       constexpr auto WGDimensions = decltype(WGSize)::dimensions;
@@ -379,24 +379,20 @@ constexpr void validateKernelProperties() {
           WGDimensions == MaxWGDimensions,
           "work_group_size and max_work_group_size dimensionality must match");
       if constexpr (WGDimensions == MaxWGDimensions) {
-        static_assert(
-            WGDimensions < 1 || WGSize[0] <= MaxWGSize[0],
-            "work_group_size must not exceed max_work_group_size");
-        static_assert(
-            WGDimensions < 2 || WGSize[1] <= MaxWGSize[1],
-            "work_group_size must not exceed max_work_group_size");
-        static_assert(
-            WGDimensions < 3 || WGSize[2] <= MaxWGSize[2],
-            "work_group_size must not exceed max_work_group_size");
+        static_assert(WGDimensions < 1 || WGSize[0] <= MaxWGSize[0],
+                      "work_group_size must not exceed max_work_group_size");
+        static_assert(WGDimensions < 2 || WGSize[1] <= MaxWGSize[1],
+                      "work_group_size must not exceed max_work_group_size");
+        static_assert(WGDimensions < 3 || WGSize[2] <= MaxWGSize[2],
+                      "work_group_size must not exceed max_work_group_size");
       }
     }
 
     if constexpr (PropertiesT::template has_property<
                       max_linear_work_group_size_key>()) {
       constexpr auto Dimensions = decltype(WGSize)::dimensions;
-      constexpr auto LinearSize =
-          WGSize[0] * (Dimensions > 1 ? WGSize[1] : 1) *
-          (Dimensions > 2 ? WGSize[2] : 1);
+      constexpr auto LinearSize = WGSize[0] * (Dimensions > 1 ? WGSize[1] : 1) *
+                                  (Dimensions > 2 ? WGSize[2] : 1);
       constexpr auto MaxLinearWGSize =
           PropertiesT::template get_property<max_linear_work_group_size_key>();
 
diff --git a/sycl/include/sycl/ext/oneapi/free_function_kernel_properties.hpp b/sycl/include/sycl/ext/oneapi/free_function_kernel_properties.hpp
index 348478ac61272..09f7b6e99d4ae 100644
--- a/sycl/include/sycl/ext/oneapi/free_function_kernel_properties.hpp
+++ b/sycl/include/sycl/ext/oneapi/free_function_kernel_properties.hpp
@@ -25,11 +25,11 @@ using remove_cvref_t = std::remove_cv_t<std::remove_reference_t<T>>;
 template <typename PropertyT> struct FunctionPropertyMetaInfo;
 
 template <size_t... Xs> struct FunctionPropertyAllNonZero {
-	static constexpr bool value = true;
+  static constexpr bool value = true;
 };
 template <size_t X, size_t... Xs> struct FunctionPropertyAllNonZero<X, Xs...> {
-	static constexpr bool value =
-			X > 0 && FunctionPropertyAllNonZero<Xs...>::value;
+  static constexpr bool value =
+      X > 0 && FunctionPropertyAllNonZero<Xs...>::value;
 };
 
 inline constexpr size_t FunctionPropertyDecimalBase = 10;
@@ -38,7 +38,7 @@ template <size_t... Sizes> struct FunctionPropertySizeList {};
 template <char... Chars> struct FunctionPropertyCharList {};
 
 template <char... Chars> struct FunctionPropertyCharsToStr {
-	static constexpr const char value[] = {Chars..., '\0'};
+  static constexpr const char value[] = {Chars..., '\0'};
 };
 
 template <typename List, typename ParsedList, char... Chars>
@@ -46,82 +46,82 @@ struct FunctionPropertySizeListToStrHelper;
 
 template <size_t Value, size_t... Values, char... ParsedChars, char... Chars>
 struct FunctionPropertySizeListToStrHelper<
-		FunctionPropertySizeList<Value, Values...>,
-		FunctionPropertyCharList<ParsedChars...>, Chars...>
-		: FunctionPropertySizeListToStrHelper<
-					FunctionPropertySizeList<Value / FunctionPropertyDecimalBase,
-																	 Values...>,
-					FunctionPropertyCharList<ParsedChars...>,
-					'0' + (Value % FunctionPropertyDecimalBase), Chars...> {};
+    FunctionPropertySizeList<Value, Values...>,
+    FunctionPropertyCharList<ParsedChars...>, Chars...>
+    : FunctionPropertySizeListToStrHelper<
+          FunctionPropertySizeList<Value / FunctionPropertyDecimalBase,
+                                   Values...>,
+          FunctionPropertyCharList<ParsedChars...>,
+          '0' + (Value % FunctionPropertyDecimalBase), Chars...> {};
 
 template <size_t... Values, char... ParsedChars, char... Chars>
 struct FunctionPropertySizeListToStrHelper<
-		FunctionPropertySizeList<0, Values...>,
-		FunctionPropertyCharList<ParsedChars...>, Chars...>
-		: FunctionPropertySizeListToStrHelper<
-					FunctionPropertySizeList<Values...>,
-					FunctionPropertyCharList<ParsedChars..., Chars..., ','>> {};
+    FunctionPropertySizeList<0, Values...>,
+    FunctionPropertyCharList<ParsedChars...>, Chars...>
+    : FunctionPropertySizeListToStrHelper<
+          FunctionPropertySizeList<Values...>,
+          FunctionPropertyCharList<ParsedChars..., Chars..., ','>> {};
 
 template <size_t... Values, char... ParsedChars>
 struct FunctionPropertySizeListToStrHelper<
-		FunctionPropertySizeList<0, Values...>,
-		FunctionPropertyCharList<ParsedChars...>>
-		: FunctionPropertySizeListToStrHelper<
-					FunctionPropertySizeList<Values...>,
-					FunctionPropertyCharList<ParsedChars..., '0', ','>> {};
+    FunctionPropertySizeList<0, Values...>,
+    FunctionPropertyCharList<ParsedChars...>>
+    : FunctionPropertySizeListToStrHelper<
+          FunctionPropertySizeList<Values...>,
+          FunctionPropertyCharList<ParsedChars..., '0', ','>> {};
 
 template <char... ParsedChars, char... Chars>
 struct FunctionPropertySizeListToStrHelper<
-		FunctionPropertySizeList<0>, FunctionPropertyCharList<ParsedChars...>,
-		Chars...> : FunctionPropertyCharsToStr<ParsedChars..., Chars...> {};
+    FunctionPropertySizeList<0>, FunctionPropertyCharList<ParsedChars...>,
+    Chars...> : FunctionPropertyCharsToStr<ParsedChars..., Chars...> {};
 
 template <char... ParsedChars>
 struct FunctionPropertySizeListToStrHelper<
-		FunctionPropertySizeList<0>, FunctionPropertyCharList<ParsedChars...>>
-		: FunctionPropertyCharsToStr<ParsedChars..., '0'> {};
+    FunctionPropertySizeList<0>, FunctionPropertyCharList<ParsedChars...>>
+    : FunctionPropertyCharsToStr<ParsedChars..., '0'> {};
 
 template <>
 struct FunctionPropertySizeListToStrHelper<FunctionPropertySizeList<>,
-																					 FunctionPropertyCharList<>>
-		: FunctionPropertyCharsToStr<> {};
+                                           FunctionPropertyCharList<>>
+    : FunctionPropertyCharsToStr<> {};
 
 template <size_t... Sizes>
 struct FunctionPropertySizeListToStr
-		: FunctionPropertySizeListToStrHelper<FunctionPropertySizeList<Sizes...>,
-																					FunctionPropertyCharList<>> {};
+    : FunctionPropertySizeListToStrHelper<FunctionPropertySizeList<Sizes...>,
+                                          FunctionPropertyCharList<>> {};
 
 } // namespace detail
 
 struct nd_range_kernel_key
-		: detail::compile_time_property_key<detail::PropKind::NDRangeKernel> {
-	template <int Dims>
-	using value_t =
-			property_value<nd_range_kernel_key, std::integral_constant<int, Dims>>;
+    : detail::compile_time_property_key<detail::PropKind::NDRangeKernel> {
+  template <int Dims>
+  using value_t =
+      property_value<nd_range_kernel_key, std::integral_constant<int, Dims>>;
 };
 
 struct single_task_kernel_key
-		: detail::compile_time_property_key<detail::PropKind::SingleTaskKernel> {
-	using value_t = property_value<single_task_kernel_key>;
+    : detail::compile_time_property_key<detail::PropKind::SingleTaskKernel> {
+  using value_t = property_value<single_task_kernel_key>;
 };
 
 template <int Dims>
 struct property_value<nd_range_kernel_key, std::integral_constant<int, Dims>>
-		: detail::property_base<property_value<nd_range_kernel_key,
-																					 std::integral_constant<int, Dims>>,
-														detail::PropKind::NDRangeKernel,
-														nd_range_kernel_key> {
-	static_assert(Dims >= 1 && Dims <= 3,
-								"nd_range_kernel must use dimension 1, 2, or 3.");
-
-	using value_t = int;
-	static constexpr int dimensions = Dims;
+    : detail::property_base<property_value<nd_range_kernel_key,
+                                           std::integral_constant<int, Dims>>,
+                            detail::PropKind::NDRangeKernel,
+                            nd_range_kernel_key> {
+  static_assert(Dims >= 1 && Dims <= 3,
+                "nd_range_kernel must use dimension 1, 2, or 3.");
+
+  using value_t = int;
+  static constexpr int dimensions = Dims;
 };
 
 template <>
 struct property_value<single_task_kernel_key>
-		: detail::property_base<property_value<single_task_kernel_key>,
-														detail::PropKind::SingleTaskKernel,
-														single_task_kernel_key> {};
+    : detail::property_base<property_value<single_task_kernel_key>,
+                            detail::PropKind::SingleTaskKernel,
+                            single_task_kernel_key> {};
 
 template <int Dims>
 inline constexpr nd_range_kernel_key::value_t<Dims> nd_range_kernel;
@@ -129,135 +129,135 @@ inline constexpr nd_range_kernel_key::value_t<Dims> nd_range_kernel;
 inline constexpr single_task_kernel_key::value_t single_task_kernel;
 
 struct work_group_size_key
-		: detail::compile_time_property_key<detail::PropKind::WorkGroupSize> {
-	template <size_t... Dims>
-	using value_t = property_value<work_group_size_key,
-																 std::integral_constant<size_t, Dims>...>;
+    : detail::compile_time_property_key<detail::PropKind::WorkGroupSize> {
+  template <size_t... Dims>
+  using value_t = property_value<work_group_size_key,
+                                 std::integral_constant<size_t, Dims>...>;
 };
 
 struct work_group_size_hint_key
-		: detail::compile_time_property_key<detail::PropKind::WorkGroupSizeHint> {
-	template <size_t... Dims>
-	using value_t = property_value<work_group_size_hint_key,
-																 std::integral_constant<size_t, Dims>...>;
+    : detail::compile_time_property_key<detail::PropKind::WorkGroupSizeHint> {
+  template <size_t... Dims>
+  using value_t = property_value<work_group_size_hint_key,
+                                 std::integral_constant<size_t, Dims>...>;
 };
 
 struct sub_group_size_key
-		: detail::compile_time_property_key<detail::PropKind::SubGroupSize> {
-	template <uint32_t Size>
-	using value_t = property_value<sub_group_size_key,
-																 std::integral_constant<uint32_t, Size>>;
+    : detail::compile_time_property_key<detail::PropKind::SubGroupSize> {
+  template <uint32_t Size>
+  using value_t = property_value<sub_group_size_key,
+                                 std::integral_constant<uint32_t, Size>>;
 };
 
 struct max_work_group_size_key
-		: detail::compile_time_property_key<detail::PropKind::MaxWorkGroupSize> {
-	template <size_t... Dims>
-	using value_t = property_value<max_work_group_size_key,
-																 std::integral_constant<size_t, Dims>...>;
+    : detail::compile_time_property_key<detail::PropKind::MaxWorkGroupSize> {
+  template <size_t... Dims>
+  using value_t = property_value<max_work_group_size_key,
+                                 std::integral_constant<size_t, Dims>...>;
 };
 
 struct max_linear_work_group_size_key
-		: detail::compile_time_property_key<
-					detail::PropKind::MaxLinearWorkGroupSize> {
-	template <size_t Size>
-	using value_t = property_value<max_linear_work_group_size_key,
-																 std::integral_constant<size_t, Size>>;
+    : detail::compile_time_property_key<
+          detail::PropKind::MaxLinearWorkGroupSize> {
+  template <size_t Size>
+  using value_t = property_value<max_linear_work_group_size_key,
+                                 std::integral_constant<size_t, Size>>;
 };
 
 template <size_t Dim0, size_t... Dims>
 struct property_value<work_group_size_key, std::integral_constant<size_t, Dim0>,
-											std::integral_constant<size_t, Dims>...>
-		: detail::property_base<
-					property_value<work_group_size_key,
-												 std::integral_constant<size_t, Dim0>,
-												 std::integral_constant<size_t, Dims>...>,
-					detail::PropKind::WorkGroupSize, work_group_size_key> {
-	static_assert(
-			sizeof...(Dims) + 1 <= 3,
-			"work_group_size property currently only supports up to three values.");
-	static_assert(detail::FunctionPropertyAllNonZero<Dim0, Dims...>::value,
-								"work_group_size property must only contain non-zero values.");
-
-	static constexpr size_t dimensions = sizeof...(Dims) + 1;
-
-	constexpr size_t operator[](int Dim) const {
-		constexpr size_t Values[] = {Dim0, Dims...};
-		return Values[Dim];
-	}
+                      std::integral_constant<size_t, Dims>...>
+    : detail::property_base<
+          property_value<work_group_size_key,
+                         std::integral_constant<size_t, Dim0>,
+                         std::integral_constant<size_t, Dims>...>,
+          detail::PropKind::WorkGroupSize, work_group_size_key> {
+  static_assert(
+      sizeof...(Dims) + 1 <= 3,
+      "work_group_size property currently only supports up to three values.");
+  static_assert(detail::FunctionPropertyAllNonZero<Dim0, Dims...>::value,
+                "work_group_size property must only contain non-zero values.");
+
+  static constexpr size_t dimensions = sizeof...(Dims) + 1;
+
+  constexpr size_t operator[](int Dim) const {
+    constexpr size_t Values[] = {Dim0, Dims...};
+    return Values[Dim];
+  }
 };
 
 template <size_t Dim0, size_t... Dims>
 struct property_value<work_group_size_hint_key,
-											std::integral_constant<size_t, Dim0>,
-											std::integral_constant<size_t, Dims>...>
-		: detail::property_base<
-					property_value<work_group_size_hint_key,
-												 std::integral_constant<size_t, Dim0>,
-												 std::integral_constant<size_t, Dims>...>,
-					detail::PropKind::WorkGroupSizeHint, work_group_size_hint_key> {
-	static_assert(sizeof...(Dims) + 1 <= 3,
-								"work_group_size_hint property currently only supports up to "
-								"three values.");
-	static_assert(
-			detail::FunctionPropertyAllNonZero<Dim0, Dims...>::value,
-			"work_group_size_hint property must only contain non-zero values.");
-
-	constexpr size_t operator[](int Dim) const {
-		constexpr size_t Values[] = {Dim0, Dims...};
-		return Values[Dim];
-	}
+                      std::integral_constant<size_t, Dim0>,
+                      std::integral_constant<size_t, Dims>...>
+    : detail::property_base<
+          property_value<work_group_size_hint_key,
+                         std::integral_constant<size_t, Dim0>,
+                         std::integral_constant<size_t, Dims>...>,
+          detail::PropKind::WorkGroupSizeHint, work_group_size_hint_key> {
+  static_assert(sizeof...(Dims) + 1 <= 3,
+                "work_group_size_hint property currently only supports up to "
+                "three values.");
+  static_assert(
+      detail::FunctionPropertyAllNonZero<Dim0, Dims...>::value,
+      "work_group_size_hint property must only contain non-zero values.");
+
+  constexpr size_t operator[](int Dim) const {
+    constexpr size_t Values[] = {Dim0, Dims...};
+    return Values[Dim];
+  }
 };
 
 template <uint32_t Size>
 struct property_value<sub_group_size_key,
-											std::integral_constant<uint32_t, Size>>
-		: detail::property_base<
-					property_value<sub_group_size_key,
-												 std::integral_constant<uint32_t, Size>>,
-					detail::PropKind::SubGroupSize, sub_group_size_key> {
-	static_assert(Size != 0,
-								"sub_group_size property must contain a non-zero value.");
-
-	using value_t = std::integral_constant<uint32_t, Size>;
-	static constexpr uint32_t value = Size;
+                      std::integral_constant<uint32_t, Size>>
+    : detail::property_base<
+          property_value<sub_group_size_key,
+                         std::integral_constant<uint32_t, Size>>,
+          detail::PropKind::SubGroupSize, sub_group_size_key> {
+  static_assert(Size != 0,
+                "sub_group_size property must contain a non-zero value.");
+
+  using value_t = std::integral_constant<uint32_t, Size>;
+  static constexpr uint32_t value = Size;
 };
 
 template <size_t Dim0, size_t... Dims>
 struct property_value<max_work_group_size_key,
-											std::integral_constant<size_t, Dim0>,
-											std::integral_constant<size_t, Dims>...>
-		: detail::property_base<
-					property_value<max_work_group_size_key,
-												 std::integral_constant<size_t, Dim0>,
-												 std::integral_constant<size_t, Dims>...>,
-					detail::PropKind::MaxWorkGroupSize, max_work_group_size_key> {
-	static_assert(
-			sizeof...(Dims) + 1 <= 3,
-			"max_work_group_size currently only supports up to three values.");
-	static_assert(detail::FunctionPropertyAllNonZero<Dim0, Dims...>::value,
-								"max_work_group_size must only contain non-zero values.");
-
-	static constexpr size_t dimensions = sizeof...(Dims) + 1;
-
-	constexpr size_t operator[](int Dim) const {
-		constexpr size_t Values[] = {Dim0, Dims...};
-		return Values[Dim];
-	}
+                      std::integral_constant<size_t, Dim0>,
+                      std::integral_constant<size_t, Dims>...>
+    : detail::property_base<
+          property_value<max_work_group_size_key,
+                         std::integral_constant<size_t, Dim0>,
+                         std::integral_constant<size_t, Dims>...>,
+          detail::PropKind::MaxWorkGroupSize, max_work_group_size_key> {
+  static_assert(
+      sizeof...(Dims) + 1 <= 3,
+      "max_work_group_size currently only supports up to three values.");
+  static_assert(detail::FunctionPropertyAllNonZero<Dim0, Dims...>::value,
+                "max_work_group_size must only contain non-zero values.");
+
+  static constexpr size_t dimensions = sizeof...(Dims) + 1;
+
+  constexpr size_t operator[](int Dim) const {
+    constexpr size_t Values[] = {Dim0, Dims...};
+    return Values[Dim];
+  }
 };
 
 template <size_t Size>
 struct property_value<max_linear_work_group_size_key,
-											std::integral_constant<size_t, Size>>
-		: detail::property_base<
-					property_value<max_linear_work_group_size_key,
-												 std::integral_constant<size_t, Size>>,
-					detail::PropKind::MaxLinearWorkGroupSize,
-					max_linear_work_group_size_key> {
-	static_assert(Size != 0,
-								"max_linear_work_group_size must contain a non-zero value.");
-
-	using value_t = std::integral_constant<size_t, Size>;
-	static constexpr size_t value = Size;
+                      std::integral_constant<size_t, Size>>
+    : detail::property_base<
+          property_value<max_linear_work_group_size_key,
+                         std::integral_constant<size_t, Size>>,
+          detail::PropKind::MaxLinearWorkGroupSize,
+          max_linear_work_group_size_key> {
+  static_assert(Size != 0,
+                "max_linear_work_group_size must contain a non-zero value.");
+
+  using value_t = std::integral_constant<size_t, Size>;
+  static constexpr size_t value = Size;
 };
 
 template <size_t Dim0, size_t... Dims>
@@ -265,109 +265,109 @@ inline constexpr work_group_size_key::value_t<Dim0, Dims...> work_group_size;
 
 template <size_t Dim0, size_t... Dims>
 inline constexpr work_group_size_hint_key::value_t<Dim0, Dims...>
-		work_group_size_hint;
+    work_group_size_hint;
 
 template <uint32_t Size>
 inline constexpr sub_group_size_key::value_t<Size> sub_group_size;
 
 template <size_t Dim0, size_t... Dims>
 inline constexpr max_work_group_size_key::value_t<Dim0, Dims...>
-		max_work_group_size;
+    max_work_group_size;
 
 template <size_t Size>
 inline constexpr max_linear_work_group_size_key::value_t<Size>
-		max_linear_work_group_size;
+    max_linear_work_group_size;
 
 namespace detail {
 
 template <int Dims>
 struct FunctionPropertyMetaInfo<nd_range_kernel_key::value_t<Dims>> {
-	static constexpr const char *name = "sycl-nd-range-kernel";
-	static constexpr int value = Dims;
+  static constexpr const char *name = "sycl-nd-range-kernel";
+  static constexpr int value = Dims;
 };
 
 template <> struct FunctionPropertyMetaInfo<single_task_kernel_key::value_t> {
-	static constexpr const char *name = "sycl-single-task-kernel";
-	static constexpr int value = 0;
+  static constexpr const char *name = "sycl-single-task-kernel";
+  static constexpr int value = 0;
 };
 
 template <size_t... Dims>
 struct HasCompileTimeEffect<work_group_size_key::value_t<Dims...>>
-		: std::true_type {};
+    : std::true_type {};
 template <size_t... Dims>
 struct HasCompileTimeEffect<work_group_size_hint_key::value_t<Dims...>>
-		: std::true_type {};
+    : std::true_type {};
 template <uint32_t Size>
 struct HasCompileTimeEffect<sub_group_size_key::value_t<Size>>
-		: std::true_type {};
+    : std::true_type {};
 template <size_t... Dims>
 struct HasCompileTimeEffect<max_work_group_size_key::value_t<Dims...>>
-		: std::true_type {};
+    : std::true_type {};
 template <size_t Size>
 struct HasCompileTimeEffect<max_linear_work_group_size_key::value_t<Size>>
-		: std::true_type {};
+    : std::true_type {};
 
 template <size_t Dim0, size_t... Dims>
 struct PropertyMetaInfo<work_group_size_key::value_t<Dim0, Dims...>> {
-	static constexpr const char *name = "sycl-work-group-size";
-	static constexpr const char *value =
-			FunctionPropertySizeListToStr<Dim0, Dims...>::value;
+  static constexpr const char *name = "sycl-work-group-size";
+  static constexpr const char *value =
+      FunctionPropertySizeListToStr<Dim0, Dims...>::value;
 };
 template <size_t Dim0, size_t... Dims>
 struct FunctionPropertyMetaInfo<work_group_size_key::value_t<Dim0, Dims...>> {
-	static constexpr const char *name = "sycl-work-group-size";
-	static constexpr const char *value =
-			FunctionPropertySizeListToStr<Dim0, Dims...>::value;
+  static constexpr const char *name = "sycl-work-group-size";
+  static constexpr const char *value =
+      FunctionPropertySizeListToStr<Dim0, Dims...>::value;
 };
 
 template <size_t Dim0, size_t... Dims>
 struct PropertyMetaInfo<work_group_size_hint_key::value_t<Dim0, Dims...>> {
-	static constexpr const char *name = "sycl-work-group-size-hint";
-	static constexpr const char *value =
-			FunctionPropertySizeListToStr<Dim0, Dims...>::value;
+  static constexpr const char *name = "sycl-work-group-size-hint";
+  static constexpr const char *value =
+      FunctionPropertySizeListToStr<Dim0, Dims...>::value;
 };
 template <size_t Dim0, size_t... Dims>
 struct FunctionPropertyMetaInfo<
-		work_group_size_hint_key::value_t<Dim0, Dims...>> {
-	static constexpr const char *name = "sycl-work-group-size-hint";
-	static constexpr const char *value =
-			FunctionPropertySizeListToStr<Dim0, Dims...>::value;
+    work_group_size_hint_key::value_t<Dim0, Dims...>> {
+  static constexpr const char *name = "sycl-work-group-size-hint";
+  static constexpr const char *value =
+      FunctionPropertySizeListToStr<Dim0, Dims...>::value;
 };
 
 template <uint32_t Size>
 struct PropertyMetaInfo<sub_group_size_key::value_t<Size>> {
-	static constexpr const char *name = "sycl-sub-group-size";
-	static constexpr uint32_t value = Size;
+  static constexpr const char *name = "sycl-sub-group-size";
+  static constexpr uint32_t value = Size;
 };
 template <uint32_t Size>
 struct FunctionPropertyMetaInfo<sub_group_size_key::value_t<Size>> {
-	static constexpr const char *name = "sycl-sub-group-size";
-	static constexpr uint32_t value = Size;
+  static constexpr const char *name = "sycl-sub-group-size";
+  static constexpr uint32_t value = Size;
 };
 
 template <size_t Dim0, size_t... Dims>
 struct PropertyMetaInfo<max_work_group_size_key::value_t<Dim0, Dims...>> {
-	static constexpr const char *name = "sycl-max-work-group-size";
-	static constexpr const char *value =
-			FunctionPropertySizeListToStr<Dim0, Dims...>::value;
+  static constexpr const char *name = "sycl-max-work-group-size";
+  static constexpr const char *value =
+      FunctionPropertySizeListToStr<Dim0, Dims...>::value;
 };
 template <size_t Dim0, size_t... Dims>
 struct FunctionPropertyMetaInfo<
-		max_work_group_size_key::value_t<Dim0, Dims...>> {
-	static constexpr const char *name = "sycl-max-work-group-size";
-	static constexpr const char *value =
-			FunctionPropertySizeListToStr<Dim0, Dims...>::value;
+    max_work_group_size_key::value_t<Dim0, Dims...>> {
+  static constexpr const char *name = "sycl-max-work-group-size";
+  static constexpr const char *value =
+      FunctionPropertySizeListToStr<Dim0, Dims...>::value;
 };
 
 template <size_t Size>
 struct PropertyMetaInfo<max_linear_work_group_size_key::value_t<Size>> {
-	static constexpr const char *name = "sycl-max-linear-work-group-size";
-	static constexpr size_t value = Size;
+  static constexpr const char *name = "sycl-max-linear-work-group-size";
+  static constexpr size_t value = Size;
 };
 template <size_t Size>
 struct FunctionPropertyMetaInfo<max_linear_work_group_size_key::value_t<Size>> {
-	static constexpr const char *name = "sycl-max-linear-work-group-size";
-	static constexpr size_t value = Size;
+  static constexpr const char *name = "sycl-max-linear-work-group-size";
+  static constexpr size_t value = Size;
 };
 
 } // namespace detail
@@ -377,13 +377,13 @@ struct FunctionPropertyMetaInfo<max_linear_work_group_size_key::value_t<Size>> {
 
 #ifdef __SYCL_DEVICE_ONLY__
 #define SYCL_EXT_ONEAPI_FUNCTION_PROPERTY(PROP)                                \
-	[[__sycl_detail__::add_ir_attributes_function(                               \
-			sycl::ext::oneapi::experimental::detail::FunctionPropertyMetaInfo<       \
-					sycl::ext::oneapi::experimental::detail::remove_cvref_t<             \
-							decltype(PROP)>>::name,                                          \
-			sycl::ext::oneapi::experimental::detail::FunctionPropertyMetaInfo<       \
-					sycl::ext::oneapi::experimental::detail::remove_cvref_t<             \
-							decltype(PROP)>>::value)]]
+  [[__sycl_detail__::add_ir_attributes_function(                               \
+      sycl::ext::oneapi::experimental::detail::FunctionPropertyMetaInfo<       \
+          sycl::ext::oneapi::experimental::detail::remove_cvref_t<             \
+              decltype(PROP)>>::name,                                          \
+      sycl::ext::oneapi::experimental::detail::FunctionPropertyMetaInfo<       \
+          sycl::ext::oneapi::experimental::detail::remove_cvref_t<             \
+              decltype(PROP)>>::value)]]
 #else
 #define SYCL_EXT_ONEAPI_FUNCTION_PROPERTY(PROP)
 #endif
\ No newline at end of file
diff --git a/sycl/include/sycl/ext/oneapi/kernel_properties.hpp b/sycl/include/sycl/ext/oneapi/kernel_properties.hpp
index 06a01cb51288f..fe4bd30269580 100644
--- a/sycl/include/sycl/ext/oneapi/kernel_properties.hpp
+++ b/sycl/include/sycl/ext/oneapi/kernel_properties.hpp
@@ -25,133 +25,133 @@ namespace ext::oneapi::experimental {
 struct properties_tag {};
 
 struct device_has_key
-		: detail::compile_time_property_key<detail::PropKind::DeviceHas> {
-	template <aspect... Aspects>
-	using value_t = property_value<device_has_key,
-																 std::integral_constant<aspect, Aspects>...>;
+    : detail::compile_time_property_key<detail::PropKind::DeviceHas> {
+  template <aspect... Aspects>
+  using value_t = property_value<device_has_key,
+                                 std::integral_constant<aspect, Aspects>...>;
 };
 
 template <aspect... Aspects>
 struct property_value<device_has_key,
-											std::integral_constant<aspect, Aspects>...>
-		: detail::property_base<
-					property_value<device_has_key,
-												 std::integral_constant<aspect, Aspects>...>,
-					detail::PropKind::DeviceHas, device_has_key> {
-	static constexpr std::array<aspect, sizeof...(Aspects)> value{Aspects...};
+                      std::integral_constant<aspect, Aspects>...>
+    : detail::property_base<
+          property_value<device_has_key,
+                         std::integral_constant<aspect, Aspects>...>,
+          detail::PropKind::DeviceHas, device_has_key> {
+  static constexpr std::array<aspect, sizeof...(Aspects)> value{Aspects...};
 };
 
 template <aspect... Aspects>
 inline constexpr device_has_key::value_t<Aspects...> device_has;
 
 struct work_group_progress_key
-		: detail::compile_time_property_key<detail::PropKind::WorkGroupProgress> {
-	template <forward_progress_guarantee Guarantee,
-						execution_scope CoordinationScope>
-	using value_t = property_value<
-			work_group_progress_key,
-			std::integral_constant<forward_progress_guarantee, Guarantee>,
-			std::integral_constant<execution_scope, CoordinationScope>>;
+    : detail::compile_time_property_key<detail::PropKind::WorkGroupProgress> {
+  template <forward_progress_guarantee Guarantee,
+            execution_scope CoordinationScope>
+  using value_t = property_value<
+      work_group_progress_key,
+      std::integral_constant<forward_progress_guarantee, Guarantee>,
+      std::integral_constant<execution_scope, CoordinationScope>>;
 };
 
 struct sub_group_progress_key
-		: detail::compile_time_property_key<detail::PropKind::SubGroupProgress> {
-	template <forward_progress_guarantee Guarantee,
-						execution_scope CoordinationScope>
-	using value_t = property_value<
-			sub_group_progress_key,
-			std::integral_constant<forward_progress_guarantee, Guarantee>,
-			std::integral_constant<execution_scope, CoordinationScope>>;
+    : detail::compile_time_property_key<detail::PropKind::SubGroupProgress> {
+  template <forward_progress_guarantee Guarantee,
+            execution_scope CoordinationScope>
+  using value_t = property_value<
+      sub_group_progress_key,
+      std::integral_constant<forward_progress_guarantee, Guarantee>,
+      std::integral_constant<execution_scope, CoordinationScope>>;
 };
 
 struct work_item_progress_key
-		: detail::compile_time_property_key<detail::PropKind::WorkItemProgress> {
-	template <forward_progress_guarantee Guarantee,
-						execution_scope CoordinationScope>
-	using value_t = property_value<
-			work_item_progress_key,
-			std::integral_constant<forward_progress_guarantee, Guarantee>,
-			std::integral_constant<execution_scope, CoordinationScope>>;
+    : detail::compile_time_property_key<detail::PropKind::WorkItemProgress> {
+  template <forward_progress_guarantee Guarantee,
+            execution_scope CoordinationScope>
+  using value_t = property_value<
+      work_item_progress_key,
+      std::integral_constant<forward_progress_guarantee, Guarantee>,
+      std::integral_constant<execution_scope, CoordinationScope>>;
 };
 
 template <forward_progress_guarantee Guarantee,
-					execution_scope CoordinationScope>
+          execution_scope CoordinationScope>
 struct property_value<
-		work_group_progress_key,
-		std::integral_constant<forward_progress_guarantee, Guarantee>,
-		std::integral_constant<execution_scope, CoordinationScope>>
-		: detail::property_base<
-					property_value<
-							work_group_progress_key,
-							std::integral_constant<forward_progress_guarantee, Guarantee>,
-							std::integral_constant<execution_scope, CoordinationScope>>,
-					detail::PropKind::WorkGroupProgress, work_group_progress_key> {
-	static constexpr forward_progress_guarantee guarantee = Guarantee;
-	static constexpr execution_scope coordinationScope = CoordinationScope;
+    work_group_progress_key,
+    std::integral_constant<forward_progress_guarantee, Guarantee>,
+    std::integral_constant<execution_scope, CoordinationScope>>
+    : detail::property_base<
+          property_value<
+              work_group_progress_key,
+              std::integral_constant<forward_progress_guarantee, Guarantee>,
+              std::integral_constant<execution_scope, CoordinationScope>>,
+          detail::PropKind::WorkGroupProgress, work_group_progress_key> {
+  static constexpr forward_progress_guarantee guarantee = Guarantee;
+  static constexpr execution_scope coordinationScope = CoordinationScope;
 };
 
 template <forward_progress_guarantee Guarantee,
-					execution_scope CoordinationScope>
+          execution_scope CoordinationScope>
 struct property_value<
-		sub_group_progress_key,
-		std::integral_constant<forward_progress_guarantee, Guarantee>,
-		std::integral_constant<execution_scope, CoordinationScope>>
-		: detail::property_base<
-					property_value<
-							sub_group_progress_key,
-							std::integral_constant<forward_progress_guarantee, Guarantee>,
-							std::integral_constant<execution_scope, CoordinationScope>>,
-					detail::PropKind::SubGroupProgress, sub_group_progress_key> {
-	static constexpr forward_progress_guarantee guarantee = Guarantee;
-	static constexpr execution_scope coordinationScope = CoordinationScope;
+    sub_group_progress_key,
+    std::integral_constant<forward_progress_guarantee, Guarantee>,
+    std::integral_constant<execution_scope, CoordinationScope>>
+    : detail::property_base<
+          property_value<
+              sub_group_progress_key,
+              std::integral_constant<forward_progress_guarantee, Guarantee>,
+              std::integral_constant<execution_scope, CoordinationScope>>,
+          detail::PropKind::SubGroupProgress, sub_group_progress_key> {
+  static constexpr forward_progress_guarantee guarantee = Guarantee;
+  static constexpr execution_scope coordinationScope = CoordinationScope;
 };
 
 template <forward_progress_guarantee Guarantee,
-					execution_scope CoordinationScope>
+          execution_scope CoordinationScope>
 struct property_value<
-		work_item_progress_key,
-		std::integral_constant<forward_progress_guarantee, Guarantee>,
-		std::integral_constant<execution_scope, CoordinationScope>>
-		: detail::property_base<
-					property_value<
-							work_item_progress_key,
-							std::integral_constant<forward_progress_guarantee, Guarantee>,
-							std::integral_constant<execution_scope, CoordinationScope>>,
-					detail::PropKind::WorkItemProgress, work_item_progress_key> {
-	static constexpr forward_progress_guarantee guarantee = Guarantee;
-	static constexpr execution_scope coordinationScope = CoordinationScope;
+    work_item_progress_key,
+    std::integral_constant<forward_progress_guarantee, Guarantee>,
+    std::integral_constant<execution_scope, CoordinationScope>>
+    : detail::property_base<
+          property_value<
+              work_item_progress_key,
+              std::integral_constant<forward_progress_guarantee, Guarantee>,
+              std::integral_constant<execution_scope, CoordinationScope>>,
+          detail::PropKind::WorkItemProgress, work_item_progress_key> {
+  static constexpr forward_progress_guarantee guarantee = Guarantee;
+  static constexpr execution_scope coordinationScope = CoordinationScope;
 };
 
 template <forward_progress_guarantee Guarantee,
-					execution_scope CoordinationScope>
+          execution_scope CoordinationScope>
 inline constexpr work_group_progress_key::value_t<Guarantee, CoordinationScope>
-		work_group_progress;
+    work_group_progress;
 
 template <forward_progress_guarantee Guarantee,
-					execution_scope CoordinationScope>
+          execution_scope CoordinationScope>
 inline constexpr sub_group_progress_key::value_t<Guarantee, CoordinationScope>
-		sub_group_progress;
+    sub_group_progress;
 
 template <forward_progress_guarantee Guarantee,
-					execution_scope CoordinationScope>
+          execution_scope CoordinationScope>
 inline constexpr work_item_progress_key::value_t<Guarantee, CoordinationScope>
-		work_item_progress;
+    work_item_progress;
 
 namespace detail {
 template <sycl::aspect... Aspects>
 struct HasCompileTimeEffect<device_has_key::value_t<Aspects...>>
-		: std::true_type {};
+    : std::true_type {};
 template <aspect... Aspects>
 struct PropertyMetaInfo<device_has_key::value_t<Aspects...>> {
-	static constexpr const char *name = "sycl-device-has";
-	static constexpr const char *value =
-			SizeListToStr<static_cast<size_t>(Aspects)...>::value;
+  static constexpr const char *name = "sycl-device-has";
+  static constexpr const char *value =
+      SizeListToStr<static_cast<size_t>(Aspects)...>::value;
 };
 template <aspect... Aspects>
 struct FunctionPropertyMetaInfo<device_has_key::value_t<Aspects...>> {
-	static constexpr const char *name = "sycl-device-has";
-	static constexpr const char *value =
-			SizeListToStr<static_cast<size_t>(Aspects)...>::value;
+  static constexpr const char *name = "sycl-device-has";
+  static constexpr const char *value =
+      SizeListToStr<static_cast<size_t>(Aspects)...>::value;
 };
 
 template <typename T, typename = void>
@@ -159,23 +159,23 @@ struct HasKernelPropertiesGetMethod : std::false_type {};
 
 template <typename T>
 struct HasKernelPropertiesGetMethod<T,
-																		std::void_t<decltype(std::declval<T>().get(
-																				std::declval<properties_tag>()))>>
-		: std::true_type {
-	using properties_t =
-			decltype(std::declval<T>().get(std::declval<properties_tag>()));
+                                    std::void_t<decltype(std::declval<T>().get(
+                                        std::declval<properties_tag>()))>>
+    : std::true_type {
+  using properties_t =
+      decltype(std::declval<T>().get(std::declval<properties_tag>()));
 };
 
 template <typename... RestT>
 auto RetrieveGetMethodPropertiesOrEmpty(RestT &&...Rest) {
-	auto Identity = [](const auto &x) -> decltype(auto) { return x; };
-	const auto &KernelObj = (Identity(Rest), ...);
-	if constexpr (ext::oneapi::experimental::detail::HasKernelPropertiesGetMethod<
-										decltype(KernelObj)>::value) {
-		return KernelObj.get(ext::oneapi::experimental::properties_tag{});
-	} else {
-		return ext::oneapi::experimental::empty_properties_t{};
-	}
+  auto Identity = [](const auto &x) -> decltype(auto) { return x; };
+  const auto &KernelObj = (Identity(Rest), ...);
+  if constexpr (ext::oneapi::experimental::detail::HasKernelPropertiesGetMethod<
+                    decltype(KernelObj)>::value) {
+    return KernelObj.get(ext::oneapi::experimental::properties_tag{});
+  } else {
+    return ext::oneapi::experimental::empty_properties_t{};
+  }
 }
 
 } // namespace detail
diff --git a/sycl/include/sycl/ext/oneapi/properties.hpp b/sycl/include/sycl/ext/oneapi/properties.hpp
index 158e75e49b682..f00d0ae9577e9 100644
--- a/sycl/include/sycl/ext/oneapi/properties.hpp
+++ b/sycl/include/sycl/ext/oneapi/properties.hpp
@@ -32,11 +32,11 @@ template <int N, typename... Ts>
 using properties_nth_type_t = __type_pack_element<N, Ts...>;
 #else
 template <int N, typename T, typename... Ts> struct nth_type {
-	using type = typename nth_type<N - 1, Ts...>::type;
+  using type = typename nth_type<N - 1, Ts...>::type;
 };
 
 template <typename T, typename... Ts> struct nth_type<0, T, Ts...> {
-	using type = T;
+  using type = T;
 };
 
 template <int N, typename... Ts>
@@ -61,114 +61,114 @@ template <typename... property_tys> struct invalid_properties_type_list {};
 // hacky in its own esimd::properties piggybacking on these ones).
 template <typename... PropertyValueTs>
 using properties_t =
-		properties<detail::properties_type_list<PropertyValueTs...>>;
+    properties<detail::properties_type_list<PropertyValueTs...>>;
 
 template <typename... property_tys>
 inline constexpr bool properties_are_unique = []() constexpr -> bool {
-	if constexpr (sizeof...(property_tys) == 0) {
-		return true;
-	} else {
-		const std::array kinds = {PropertyID<property_tys>::value...};
-		auto N = kinds.size();
-		for (std::size_t i = 0; i < N; ++i)
-			for (std::size_t j = i + 1; j < N; ++j)
-				if (kinds[i] == kinds[j])
-					return false;
-
-		return true;
-	}
+  if constexpr (sizeof...(property_tys) == 0) {
+    return true;
+  } else {
+    const std::array kinds = {PropertyID<property_tys>::value...};
+    auto N = kinds.size();
+    for (std::size_t i = 0; i < N; ++i)
+      for (std::size_t j = i + 1; j < N; ++j)
+        if (kinds[i] == kinds[j])
+          return false;
+
+    return true;
+  }
 }();
 
 template <typename... property_tys>
 inline constexpr bool properties_are_sorted = []() constexpr -> bool {
-	if constexpr (sizeof...(property_tys) == 0) {
-		return true;
-	} else {
-		const std::array kinds = {PropertyID<property_tys>::value...};
-		// std::is_sorted isn't constexpr until C++20.
-		for (std::size_t idx = 1; idx < kinds.size(); ++idx)
-			if (kinds[idx - 1] >= kinds[idx])
-				return false;
-		return true;
-	}
+  if constexpr (sizeof...(property_tys) == 0) {
+    return true;
+  } else {
+    const std::array kinds = {PropertyID<property_tys>::value...};
+    // std::is_sorted isn't constexpr until C++20.
+    for (std::size_t idx = 1; idx < kinds.size(); ++idx)
+      if (kinds[idx - 1] >= kinds[idx])
+        return false;
+    return true;
+  }
 }();
 
 template <typename... property_tys>
 constexpr bool properties_are_valid_for_ctad = []() constexpr {
-	// Need `if constexpr` to avoid hard error in "unique" check when querying
-	// property kind if `property_tys` isn't a property.
-	if constexpr (!((is_property_value_v<property_tys> && ...))) {
-		return false;
-	} else if constexpr (!detail::properties_are_unique<property_tys...>) {
-		return false;
-	} else {
-		return true;
-	}
+  // Need `if constexpr` to avoid hard error in "unique" check when querying
+  // property kind if `property_tys` isn't a property.
+  if constexpr (!((is_property_value_v<property_tys> && ...))) {
+    return false;
+  } else if constexpr (!detail::properties_are_unique<property_tys...>) {
+    return false;
+  } else {
+    return true;
+  }
 }();
 
 template <typename... property_tys> struct properties_sorter {
-	// Not using "auto" due to MSVC bug in v19.36 and older. v19.37 and later is
-	// able to compile "auto" just fine. See https://godbolt.org/z/eW3rjjs7n.
-	static constexpr std::array<int, sizeof...(property_tys)> sorted_indices =
-			[]() constexpr {
-				int idx = 0;
-				int N = sizeof...(property_tys);
-				// std::sort isn't constexpr until C++20. Also, it's possible there will
-				// be a compiler builtin to sort types, in which case we should start
-				// using that.
-				std::array to_sort{
-						std::pair{PropertyID<property_tys>::value, idx++}...};
-				auto swap_pair = [](auto &x, auto &y) constexpr {
-					auto tmp_first = x.first;
-					auto tmp_second = x.second;
-					x.first = y.first;
-					x.second = y.second;
-					y.first = tmp_first;
-					y.second = tmp_second;
-				};
-				for (int i = 0; i < N; ++i)
-					for (int j = i; j < N; ++j)
-						if (to_sort[j].first < to_sort[i].first)
-							swap_pair(to_sort[i], to_sort[j]);
-
-				std::array<int, sizeof...(property_tys)> sorted_indices{};
-				for (int i = 0; i < N; ++i)
-					sorted_indices[i] = to_sort[i].second;
-
-				return sorted_indices;
-			}();
-
-	template <typename> struct helper;
-	template <int... IdxSeq>
-	struct helper<std::integer_sequence<int, IdxSeq...>> {
-		using type = properties_type_list<
-				properties_nth_type_t<sorted_indices[IdxSeq], property_tys...>...>;
-	};
-
-	using type = typename helper<
-			std::make_integer_sequence<int, sizeof...(property_tys)>>::type;
+  // Not using "auto" due to MSVC bug in v19.36 and older. v19.37 and later is
+  // able to compile "auto" just fine. See https://godbolt.org/z/eW3rjjs7n.
+  static constexpr std::array<int, sizeof...(property_tys)> sorted_indices =
+      []() constexpr {
+        int idx = 0;
+        int N = sizeof...(property_tys);
+        // std::sort isn't constexpr until C++20. Also, it's possible there will
+        // be a compiler builtin to sort types, in which case we should start
+        // using that.
+        std::array to_sort{
+            std::pair{PropertyID<property_tys>::value, idx++}...};
+        auto swap_pair = [](auto &x, auto &y) constexpr {
+          auto tmp_first = x.first;
+          auto tmp_second = x.second;
+          x.first = y.first;
+          x.second = y.second;
+          y.first = tmp_first;
+          y.second = tmp_second;
+        };
+        for (int i = 0; i < N; ++i)
+          for (int j = i; j < N; ++j)
+            if (to_sort[j].first < to_sort[i].first)
+              swap_pair(to_sort[i], to_sort[j]);
+
+        std::array<int, sizeof...(property_tys)> sorted_indices{};
+        for (int i = 0; i < N; ++i)
+          sorted_indices[i] = to_sort[i].second;
+
+        return sorted_indices;
+      }();
+
+  template <typename> struct helper;
+  template <int... IdxSeq>
+  struct helper<std::integer_sequence<int, IdxSeq...>> {
+    using type = properties_type_list<
+        properties_nth_type_t<sorted_indices[IdxSeq], property_tys...>...>;
+  };
+
+  using type = typename helper<
+      std::make_integer_sequence<int, sizeof...(property_tys)>>::type;
 };
 // Specialization to avoid zero-size array creation.
 template <> struct properties_sorter<> {
-	using type = properties_type_list<>;
+  using type = properties_type_list<>;
 };
 
 } // namespace detail
 
 // Empty property list.
 template <> class __SYCL_EBO properties<detail::properties_type_list<>> {
-	template <typename T>
-	static constexpr bool empty_properties_list_contains = false;
+  template <typename T>
+  static constexpr bool empty_properties_list_contains = false;
 
 public:
-	template <typename property_key_t> static constexpr bool has_property() {
-		return false;
-	}
-
-	// Never exists for empty property list, provide this for a better error
-	// message:
-	template <typename T>
-	static std::enable_if_t<empty_properties_list_contains<T>> get_property() {}
+  template <typename property_key_t> static constexpr bool has_property() {
+    return false;
+  }
+
+  // Never exists for empty property list, provide this for a better error
+  // message:
+  template <typename T>
+  static std::enable_if_t<empty_properties_list_contains<T>> get_property() {}
 };
 
 // Base implementation to provide nice user error in case of mis-use. Without it
@@ -176,137 +176,135 @@ template <> class __SYCL_EBO properties<detail::properties_type_list<>> {
 // class" is reported prior to static_assert's error.
 template <typename... property_tys>
 class __SYCL_EBO
-		properties<detail::invalid_properties_type_list<property_tys...>> {
+    properties<detail::invalid_properties_type_list<property_tys...>> {
 public:
-	properties(property_tys...) {
-		if constexpr (!((is_property_value_v<property_tys> && ...))) {
-			static_assert(((is_property_value_v<property_tys> && ...)),
-										"Non-property argument!");
-		} else {
-			// This is a separate specialization to report an error, we can afford
-			// doing extra work to provide nice error message without sacrificing
-			// compile time on non-exceptional path. Let's find *a* pair of properties
-			// that failed the check. Note that there might be multiple duplicate
-			// names, we're only reporting one instance. Once user addresses that, the
-			// next pair will be reported.
-			static constexpr auto conflict = []() constexpr {
-				const std::array kinds = {detail::PropertyID<property_tys>::value...};
-				auto N = kinds.size();
-				for (int i = 0; i < N; ++i)
-					for (int j = i + 1; j < N; ++j)
-						if (kinds[i] == kinds[j])
-							return std::pair{i, j};
-			}();
-			using first_type =
-					detail::properties_nth_type_t<conflict.first, property_tys...>;
-			using second_type =
-					detail::properties_nth_type_t<conflict.second, property_tys...>;
-			if constexpr (std::is_same_v<typename first_type::key_t,
-																	 typename second_type::key_t>) {
-				static_assert(!std::is_same_v<typename first_type::key_t,
-																			typename second_type::key_t>,
-											"Duplicate properties in property list.");
-			} else {
-				static_assert(
-						detail::PropertyToKind<first_type>::Kind !=
-								detail::PropertyToKind<second_type>::Kind,
-						"Property Kind collision between different property keys!");
-			}
-		}
-	}
-
-	template <typename property_key_t> static constexpr bool has_property() {
-		return false;
-	}
+  properties(property_tys...) {
+    if constexpr (!((is_property_value_v<property_tys> && ...))) {
+      static_assert(((is_property_value_v<property_tys> && ...)),
+                    "Non-property argument!");
+    } else {
+      // This is a separate specialization to report an error, we can afford
+      // doing extra work to provide nice error message without sacrificing
+      // compile time on non-exceptional path. Let's find *a* pair of properties
+      // that failed the check. Note that there might be multiple duplicate
+      // names, we're only reporting one instance. Once user addresses that, the
+      // next pair will be reported.
+      static constexpr auto conflict = []() constexpr {
+        const std::array kinds = {detail::PropertyID<property_tys>::value...};
+        auto N = kinds.size();
+        for (int i = 0; i < N; ++i)
+          for (int j = i + 1; j < N; ++j)
+            if (kinds[i] == kinds[j])
+              return std::pair{i, j};
+      }();
+      using first_type =
+          detail::properties_nth_type_t<conflict.first, property_tys...>;
+      using second_type =
+          detail::properties_nth_type_t<conflict.second, property_tys...>;
+      if constexpr (std::is_same_v<typename first_type::key_t,
+                                   typename second_type::key_t>) {
+        static_assert(!std::is_same_v<typename first_type::key_t,
+                                      typename second_type::key_t>,
+                      "Duplicate properties in property list.");
+      } else {
+        static_assert(
+            detail::PropertyToKind<first_type>::Kind !=
+                detail::PropertyToKind<second_type>::Kind,
+            "Property Kind collision between different property keys!");
+      }
+    }
+  }
+
+  template <typename property_key_t> static constexpr bool has_property() {
+    return false;
+  }
 };
 
 template <typename... property_tys>
 class __SYCL_EBO properties<detail::properties_type_list<property_tys...>>
-		: private property_tys... {
-	static_assert(detail::properties_are_sorted<property_tys...>,
-								"Properties must be sorted!");
-	using property_tys::get_property_impl...;
-
-	template <typename> friend class __SYCL_EBO properties;
-
-	template <typename prop_t> static constexpr bool is_valid_ctor_arg() {
-		return ((std::is_same_v<prop_t, property_tys> || ...));
-	}
-
-	template <typename prop_t, typename... unsorted_property_tys>
-	static constexpr bool can_be_constructed_from() {
-		return std::is_default_constructible_v<prop_t> ||
-					 ((false || ... || std::is_same_v<prop_t, unsorted_property_tys>));
-	}
-
-	// It's possible it shouldn't be that complicated, but clang doesn't accept
-	// simpler version: https://godbolt.org/z/oPff4h738, reported upstream at
-	// https://github.com/llvm/llvm-project/issues/115547. Note that if the
-	// `decltype(...)` is "inlined" then it has no issues with it, but that's too
-	// verbose.
-	struct helper : property_tys... {
-		using property_tys::get_property_impl...;
-	};
-	template <typename property_key_t>
-	using prop_t = decltype(std::declval<helper>().get_property_impl(
-			detail::property_key_tag<property_key_t>{}));
+    : private property_tys... {
+  static_assert(detail::properties_are_sorted<property_tys...>,
+                "Properties must be sorted!");
+  using property_tys::get_property_impl...;
+
+  template <typename> friend class __SYCL_EBO properties;
+
+  template <typename prop_t> static constexpr bool is_valid_ctor_arg() {
+    return ((std::is_same_v<prop_t, property_tys> || ...));
+  }
+
+  template <typename prop_t, typename... unsorted_property_tys>
+  static constexpr bool can_be_constructed_from() {
+    return std::is_default_constructible_v<prop_t> ||
+           ((false || ... || std::is_same_v<prop_t, unsorted_property_tys>));
+  }
+
+  // It's possible it shouldn't be that complicated, but clang doesn't accept
+  // simpler version: https://godbolt.org/z/oPff4h738, reported upstream at
+  // https://github.com/llvm/llvm-project/issues/115547. Note that if the
+  // `decltype(...)` is "inlined" then it has no issues with it, but that's too
+  // verbose.
+  struct helper : property_tys... {
+    using property_tys::get_property_impl...;
+  };
+  template <typename property_key_t>
+  using prop_t = decltype(std::declval<helper>().get_property_impl(
+      detail::property_key_tag<property_key_t>{}));
 
 public:
-	template <
-			typename... unsorted_property_tys,
-			typename = std::enable_if_t<
-					((is_valid_ctor_arg<unsorted_property_tys>() && ...))>,
-			typename = std::enable_if_t<
-					((can_be_constructed_from<property_tys, unsorted_property_tys...>() &&
-						...))>,
-			typename = std::enable_if_t<
-					detail::properties_are_unique<unsorted_property_tys...>>>
-	constexpr properties(unsorted_property_tys... props);
-
-	template <typename property_key_t> static constexpr bool has_property() {
-		return std::is_base_of_v<detail::property_key_tag<property_key_t>,
-														 properties>;
-	}
-
-	template <typename property_key_t>
-	static constexpr auto
-	get_property() -> std::enable_if_t<std::is_empty_v<prop_t<property_key_t>>,
-																		 prop_t<property_key_t>> {
-		return prop_t<property_key_t>{};
-	}
-
-	template <typename property_key_t>
-	constexpr auto get_property(int = 0) const
-			-> std::enable_if_t<!std::is_empty_v<prop_t<property_key_t>>,
-													prop_t<property_key_t>> {
-		return get_property_impl(detail::property_key_tag<property_key_t>{});
-	}
+  template <
+      typename... unsorted_property_tys,
+      typename = std::enable_if_t<
+          ((is_valid_ctor_arg<unsorted_property_tys>() && ...))>,
+      typename = std::enable_if_t<
+          ((can_be_constructed_from<property_tys, unsorted_property_tys...>() &&
+            ...))>,
+      typename = std::enable_if_t<
+          detail::properties_are_unique<unsorted_property_tys...>>>
+  constexpr properties(unsorted_property_tys... props);
+
+  template <typename property_key_t> static constexpr bool has_property() {
+    return std::is_base_of_v<detail::property_key_tag<property_key_t>,
+                             properties>;
+  }
+
+  template <typename property_key_t>
+  static constexpr auto get_property()
+      -> std::enable_if_t<std::is_empty_v<prop_t<property_key_t>>,
+                          prop_t<property_key_t>> {
+    return prop_t<property_key_t>{};
+  }
+
+  template <typename property_key_t>
+  constexpr auto get_property(int = 0) const
+      -> std::enable_if_t<!std::is_empty_v<prop_t<property_key_t>>,
+                          prop_t<property_key_t>> {
+    return get_property_impl(detail::property_key_tag<property_key_t>{});
+  }
 };
 
 template <typename... property_tys>
 template <typename... unsorted_property_tys, typename, typename, typename>
 constexpr properties<detail::properties_type_list<property_tys...>>::properties(
-		unsorted_property_tys... props)
-		: unsorted_property_tys(props)... {
-	static_assert(((!detail::ConflictingProperties<typename property_tys::key_t,
-																								 properties>::value &&
-									...)),
-								"Conflicting properties in property list.");
+    unsorted_property_tys... props)
+    : unsorted_property_tys(props)... {
+  static_assert(((!detail::ConflictingProperties<typename property_tys::key_t,
+                                                 properties>::value &&
+                  ...)),
+                "Conflicting properties in property list.");
 }
 
 template <typename... unsorted_property_tys,
-					typename = std::enable_if_t<
-							detail::properties_are_valid_for_ctad<unsorted_property_tys...>>>
-properties(unsorted_property_tys... props)
-		-> properties<
-				typename detail::properties_sorter<unsorted_property_tys...>::type>;
+          typename = std::enable_if_t<
+              detail::properties_are_valid_for_ctad<unsorted_property_tys...>>>
+properties(unsorted_property_tys... props) -> properties<
+    typename detail::properties_sorter<unsorted_property_tys...>::type>;
 
 template <typename... unsorted_property_tys,
-					typename = std::enable_if_t<
-							!detail::properties_are_valid_for_ctad<unsorted_property_tys...>>>
-properties(unsorted_property_tys... props)
-		-> properties<
-				detail::invalid_properties_type_list<unsorted_property_tys...>>;
+          typename = std::enable_if_t<
+              !detail::properties_are_valid_for_ctad<unsorted_property_tys...>>>
+properties(unsorted_property_tys... props) -> properties<
+    detail::invalid_properties_type_list<unsorted_property_tys...>>;
 
 using empty_properties_t = decltype(properties{});
 
@@ -314,106 +312,106 @@ namespace detail {
 
 template <template <typename> typename predicate, typename... property_tys>
 struct filter_properties_impl {
-	static constexpr auto idx_info = []() constexpr {
-		constexpr int N = sizeof...(property_tys);
-		std::array<int, N> indexes{};
-		int num_matched = 0;
-		int idx = 0;
-		(((predicate<property_tys>::value ? indexes[num_matched++] = idx++ : idx++),
-			...));
-
-		return std::pair{indexes, num_matched};
-	}();
-
-	template <int... Idx>
-	static constexpr auto idx_seq(std::integer_sequence<int, Idx...>) {
-		return std::integer_sequence<int, idx_info.first[Idx]...>{};
-	}
-
-	using selected_idx_seq =
-			decltype(idx_seq(std::make_integer_sequence<int, idx_info.second>{}));
-
-	template <typename prop_list_ty, int... Idxs>
-	static constexpr auto apply_impl(const prop_list_ty &props,
-																	 std::integer_sequence<int, Idxs...>) {
-		return properties{props.template get_property<
-				typename properties_nth_type_t<Idxs, property_tys...>::key_t>()...};
-	}
-
-	template <typename prop_list_ty>
-	static constexpr auto apply(const prop_list_ty &props) {
-		return apply_impl(props, selected_idx_seq{});
-	}
+  static constexpr auto idx_info = []() constexpr {
+    constexpr int N = sizeof...(property_tys);
+    std::array<int, N> indexes{};
+    int num_matched = 0;
+    int idx = 0;
+    (((predicate<property_tys>::value ? indexes[num_matched++] = idx++ : idx++),
+      ...));
+
+    return std::pair{indexes, num_matched};
+  }();
+
+  template <int... Idx>
+  static constexpr auto idx_seq(std::integer_sequence<int, Idx...>) {
+    return std::integer_sequence<int, idx_info.first[Idx]...>{};
+  }
+
+  using selected_idx_seq =
+      decltype(idx_seq(std::make_integer_sequence<int, idx_info.second>{}));
+
+  template <typename prop_list_ty, int... Idxs>
+  static constexpr auto apply_impl(const prop_list_ty &props,
+                                   std::integer_sequence<int, Idxs...>) {
+    return properties{props.template get_property<
+        typename properties_nth_type_t<Idxs, property_tys...>::key_t>()...};
+  }
+
+  template <typename prop_list_ty>
+  static constexpr auto apply(const prop_list_ty &props) {
+    return apply_impl(props, selected_idx_seq{});
+  }
 };
 
 template <template <typename> typename predicate, typename... property_tys>
 constexpr auto filter_properties(const properties_t<property_tys...> &props) {
-	return filter_properties_impl<predicate, property_tys...>::apply(props);
+  return filter_properties_impl<predicate, property_tys...>::apply(props);
 }
 
 template <typename... lhs_property_tys> struct merge_filter {
-	template <typename rhs_property_ty>
-	struct predicate
-			: std::bool_constant<!((std::is_same_v<typename lhs_property_tys::key_t,
-																						 typename rhs_property_ty::key_t> ||
-															...))> {};
+  template <typename rhs_property_ty>
+  struct predicate
+      : std::bool_constant<!((std::is_same_v<typename lhs_property_tys::key_t,
+                                             typename rhs_property_ty::key_t> ||
+                              ...))> {};
 };
 
 template <typename... lhs_property_tys, typename... rhs_property_tys>
 constexpr auto merge_properties(const properties_t<lhs_property_tys...> &lhs,
-																const properties_t<rhs_property_tys...> &rhs) {
-	auto rhs_unique_props =
-			filter_properties<merge_filter<lhs_property_tys...>::template predicate>(
-					rhs);
-	if constexpr (std::is_same_v<std::decay_t<decltype(rhs)>,
-															 std::decay_t<decltype(rhs_unique_props)>>) {
-		return properties{
-				lhs.template get_property<typename lhs_property_tys::key_t>()...,
-				rhs.template get_property<typename rhs_property_tys::key_t>()...};
-	} else {
-		constexpr auto has_conflict = [](auto *lhs_prop) constexpr {
-			using lhs_property_ty = std::remove_pointer_t<decltype(lhs_prop)>;
-			return (((std::is_same_v<typename lhs_property_ty::key_t,
-															 typename rhs_property_tys::key_t> &&
-								(!std::is_same_v<lhs_property_ty, rhs_property_tys> ||
-								 !std::is_empty_v<lhs_property_ty>)) ||
-							 ...));
-		};
-		static_assert(
-				!((has_conflict(static_cast<lhs_property_tys *>(nullptr)) || ...)),
-				"Failed to merge property lists due to conflicting properties.");
-		return merge_properties(lhs, rhs_unique_props);
-	}
+                                const properties_t<rhs_property_tys...> &rhs) {
+  auto rhs_unique_props =
+      filter_properties<merge_filter<lhs_property_tys...>::template predicate>(
+          rhs);
+  if constexpr (std::is_same_v<std::decay_t<decltype(rhs)>,
+                               std::decay_t<decltype(rhs_unique_props)>>) {
+    return properties{
+        lhs.template get_property<typename lhs_property_tys::key_t>()...,
+        rhs.template get_property<typename rhs_property_tys::key_t>()...};
+  } else {
+    constexpr auto has_conflict = [](auto *lhs_prop) constexpr {
+      using lhs_property_ty = std::remove_pointer_t<decltype(lhs_prop)>;
+      return (((std::is_same_v<typename lhs_property_ty::key_t,
+                               typename rhs_property_tys::key_t> &&
+                (!std::is_same_v<lhs_property_ty, rhs_property_tys> ||
+                 !std::is_empty_v<lhs_property_ty>)) ||
+               ...));
+    };
+    static_assert(
+        !((has_conflict(static_cast<lhs_property_tys *>(nullptr)) || ...)),
+        "Failed to merge property lists due to conflicting properties.");
+    return merge_properties(lhs, rhs_unique_props);
+  }
 }
 
 template <typename LHSPropertiesT, typename RHSPropertiesT>
 using merged_properties_t = decltype(merge_properties(
-		std::declval<LHSPropertiesT>(), std::declval<RHSPropertiesT>()));
+    std::declval<LHSPropertiesT>(), std::declval<RHSPropertiesT>()));
 
 template <typename property_key_t, typename prop_list_t, typename default_t>
 constexpr auto get_property_or(default_t value, const prop_list_t &props) {
-	if constexpr (prop_list_t::template has_property<property_key_t>())
-		return props.template get_property<property_key_t>();
-	else
-		return value;
+  if constexpr (prop_list_t::template has_property<property_key_t>())
+    return props.template get_property<property_key_t>();
+  else
+    return value;
 }
 template <typename property_key_t, typename prop_list_t, typename default_t>
 constexpr auto get_property_or(default_t value) {
-	if constexpr (prop_list_t::template has_property<property_key_t>())
-		return prop_list_t::template get_property<property_key_t>();
-	else
-		return value;
+  if constexpr (prop_list_t::template has_property<property_key_t>())
+    return prop_list_t::template get_property<property_key_t>();
+  else
+    return value;
 }
 
 template <typename SyclT, typename PropListT>
 struct all_are_properties_of : std::false_type {};
 template <typename SyclT, typename... Props>
 struct all_are_properties_of<SyclT, properties_t<Props...>>
-		: std::bool_constant<((is_property_value_of<Props, SyclT>::value && ...))> {
+    : std::bool_constant<((is_property_value_of<Props, SyclT>::value && ...))> {
 };
 template <typename SyclT, typename PropListT>
 inline constexpr bool all_are_properties_of_v =
-		all_are_properties_of<SyclT, PropListT>::value;
+    all_are_properties_of<SyclT, PropListT>::value;
 
 } // namespace detail
 } // namespace ext::oneapi::experimental
diff --git a/sycl/include/sycl/ext/oneapi/work_group_scratch_memory.hpp b/sycl/include/sycl/ext/oneapi/work_group_scratch_memory.hpp
index d67f523a73dcb..737a88a51d31d 100644
--- a/sycl/include/sycl/ext/oneapi/work_group_scratch_memory.hpp
+++ b/sycl/include/sycl/ext/oneapi/work_group_scratch_memory.hpp
@@ -10,7 +10,7 @@
 #include <sycl/detail/defines_elementary.hpp>      // for __SYCL_ALWAYS_INLINE
 #include <sycl/detail/sycl_local_mem_builtins.hpp> // for __sycl_allocateLocalMemory
 #include <sycl/exception.hpp>                      // for exception
-#include <sycl/ext/oneapi/properties.hpp> // for properties
+#include <sycl/ext/oneapi/properties.hpp>          // for properties
 
 namespace sycl {
 inline namespace _V1 {
diff --git a/sycl/include/sycl/queue.hpp b/sycl/include/sycl/queue.hpp
index 87304b7d1aaa5..226db93790636 100644
--- a/sycl/include/sycl/queue.hpp
+++ b/sycl/include/sycl/queue.hpp
@@ -34,7 +34,7 @@
 #include <sycl/ext/oneapi/device_global/properties.hpp> // for device_image_s...
 #include <sycl/ext/oneapi/experimental/event_mode_property.hpp>
 #include <sycl/ext/oneapi/experimental/graph.hpp>    // for command_graph...
-#include <sycl/ext/oneapi/properties.hpp> // for empty_properti...
+#include <sycl/ext/oneapi/properties.hpp>            // for empty_properti...
 #include <sycl/handler.hpp>                          // for handler, isDev...
 #include <sycl/id.hpp>                               // for id
 #include <sycl/kernel.hpp>                           // for auto_name
diff --git a/sycl/test/extensions/properties/kernel_properties_compat.cpp b/sycl/test/extensions/properties/kernel_properties_compat.cpp
index 68d21a946ae47..df6ea96056563 100644
--- a/sycl/test/extensions/properties/kernel_properties_compat.cpp
+++ b/sycl/test/extensions/properties/kernel_properties_compat.cpp
@@ -8,7 +8,8 @@
 using namespace sycl::ext::oneapi::experimental;
 
 int main() {
-  constexpr auto Props = properties{work_group_size<2, 3>, device_has<sycl::aspect::cpu>};
+  constexpr auto Props =
+      properties{work_group_size<2, 3>, device_has<sycl::aspect::cpu>};
 
   static_assert(is_property_value<decltype(single_task_kernel)>::value);
   static_assert(decltype(Props)::has_property<work_group_size_key>());
diff --git a/sycl/test/extensions/properties/properties_ctor_negative.cpp b/sycl/test/extensions/properties/properties_ctor_negative.cpp
index 4c9bad865a758..2894e0c0df11a 100644
--- a/sycl/test/extensions/properties/properties_ctor_negative.cpp
+++ b/sycl/test/extensions/properties/properties_ctor_negative.cpp
@@ -5,24 +5,24 @@
 #include "mock_compile_time_properties.hpp"
 
 int main() {
-    // expected-error-re@sycl/ext/oneapi/properties.hpp:* {{static assertion failed due to requirement {{.+}} Non-property argument!}}
+  // expected-error-re@sycl/ext/oneapi/properties.hpp:* {{static assertion failed due to requirement {{.+}} Non-property argument!}}
   auto InvalidPropertyList1 = sycl::ext::oneapi::experimental::properties(1);
-    // expected-error-re@sycl/ext/oneapi/properties.hpp:* {{static assertion failed due to requirement {{.+}} Non-property argument!}}
+  // expected-error-re@sycl/ext/oneapi/properties.hpp:* {{static assertion failed due to requirement {{.+}} Non-property argument!}}
   auto InvalidPropertyList2 = sycl::ext::oneapi::experimental::properties(
       sycl::ext::oneapi::experimental::foo{1}, true);
-    // expected-error-re@sycl/ext/oneapi/properties.hpp:* {{static assertion failed due to requirement {{.+}}: Duplicate properties in property list.}}
+  // expected-error-re@sycl/ext/oneapi/properties.hpp:* {{static assertion failed due to requirement {{.+}}: Duplicate properties in property list.}}
   auto InvalidPropertyList3 = sycl::ext::oneapi::experimental::properties(
       sycl::ext::oneapi::experimental::foo{0},
       sycl::ext::oneapi::experimental::foo{1});
-    // expected-error-re@sycl/ext/oneapi/properties.hpp:* {{static assertion failed due to requirement {{.+}}: Duplicate properties in property list.}}
+  // expected-error-re@sycl/ext/oneapi/properties.hpp:* {{static assertion failed due to requirement {{.+}}: Duplicate properties in property list.}}
   auto InvalidPropertyList4 = sycl::ext::oneapi::experimental::properties(
       sycl::ext::oneapi::experimental::bar,
       sycl::ext::oneapi::experimental::bar);
-    // expected-error-re@sycl/ext/oneapi/properties.hpp:* {{static assertion failed due to requirement {{.+}}: Conflicting properties in property list.}}
+  // expected-error-re@sycl/ext/oneapi/properties.hpp:* {{static assertion failed due to requirement {{.+}}: Conflicting properties in property list.}}
   auto InvalidPropertyList5 = sycl::ext::oneapi::experimental::properties(
       sycl::ext::oneapi::experimental::boo<int>,
       sycl::ext::oneapi::experimental::fir(3.14, false));
-    // expected-error-re@sycl/ext/oneapi/properties.hpp:* {{static assertion failed due to requirement {{.+}}: Conflicting properties in property list.}}
+  // expected-error-re@sycl/ext/oneapi/properties.hpp:* {{static assertion failed due to requirement {{.+}}: Conflicting properties in property list.}}
   auto InvalidPropertyList6 = sycl::ext::oneapi::experimental::properties(
       sycl::ext::oneapi::experimental::foo{0},
       sycl::ext::oneapi::experimental::boo<int>,
diff --git a/sycl/test/extensions/properties/properties_kernel_cache_config.cpp b/sycl/test/extensions/properties/properties_kernel_cache_config.cpp
index 040f3f1ed6fdb..d27452dbd6a14 100644
--- a/sycl/test/extensions/properties/properties_kernel_cache_config.cpp
+++ b/sycl/test/extensions/properties/properties_kernel_cache_config.cpp
@@ -27,7 +27,7 @@ int main() {
   assert(Props2.get_property<cache_config>() == large_data);
 
   // Check that duplicate cache_config can't be specified.
-    // expected-error-re@sycl/ext/oneapi/properties.hpp:* {{static assertion failed due to requirement {{.+}}: Duplicate properties in property list.}}
+  // expected-error-re@sycl/ext/oneapi/properties.hpp:* {{static assertion failed due to requirement {{.+}}: Duplicate properties in property list.}}
   sycl::ext::oneapi::experimental::properties Props3(cache_config{large_data},
                                                      cache_config{large_slm});
 }
diff --git a/sycl/test/extensions/properties/properties_kernel_negative.cpp b/sycl/test/extensions/properties/properties_kernel_negative.cpp
index 8dfdabc30bec1..ce46aec29ae03 100644
--- a/sycl/test/extensions/properties/properties_kernel_negative.cpp
+++ b/sycl/test/extensions/properties/properties_kernel_negative.cpp
@@ -30,129 +30,129 @@ void check_work_group_size() {
   // expected-error@+1 {{too few template arguments for variable template 'work_group_size'}}
   auto WGSize0 = sycl::ext::oneapi::experimental::work_group_size<>;
 
-    // expected-error-re@sycl/ext/oneapi/free_function_kernel_properties.hpp:* {{static assertion failed due to requirement {{.+}}: work_group_size property must only contain non-zero values.}}
-    // expected-error@sycl/ext/oneapi/free_function_kernel_properties.hpp:* {{constexpr variable 'work_group_size<0>' must be initialized by a constant expression}}
+  // expected-error-re@sycl/ext/oneapi/free_function_kernel_properties.hpp:* {{static assertion failed due to requirement {{.+}}: work_group_size property must only contain non-zero values.}}
+  // expected-error@sycl/ext/oneapi/free_function_kernel_properties.hpp:* {{constexpr variable 'work_group_size<0>' must be initialized by a constant expression}}
   // expected-note@+1 {{in instantiation of variable template specialization 'sycl::ext::oneapi::experimental::work_group_size<0>' requested here}}
   auto WGSize1 = sycl::ext::oneapi::experimental::work_group_size<0>;
-    // expected-error-re@sycl/ext/oneapi/free_function_kernel_properties.hpp:* {{static assertion failed due to requirement {{.+}}: work_group_size property must only contain non-zero values.}}
-    // expected-error@sycl/ext/oneapi/free_function_kernel_properties.hpp:* {{constexpr variable 'work_group_size<0, 0>' must be initialized by a constant expression}}
+  // expected-error-re@sycl/ext/oneapi/free_function_kernel_properties.hpp:* {{static assertion failed due to requirement {{.+}}: work_group_size property must only contain non-zero values.}}
+  // expected-error@sycl/ext/oneapi/free_function_kernel_properties.hpp:* {{constexpr variable 'work_group_size<0, 0>' must be initialized by a constant expression}}
   // expected-note@+1 {{in instantiation of variable template specialization 'sycl::ext::oneapi::experimental::work_group_size<0, 0>' requested here}}
   auto WGSize2 = sycl::ext::oneapi::experimental::work_group_size<0, 0>;
-    // expected-error-re@sycl/ext/oneapi/free_function_kernel_properties.hpp:* {{static assertion failed due to requirement {{.+}}: work_group_size property must only contain non-zero values.}}
-    // expected-error@sycl/ext/oneapi/free_function_kernel_properties.hpp:* {{constexpr variable 'work_group_size<1, 0>' must be initialized by a constant expression}}
+  // expected-error-re@sycl/ext/oneapi/free_function_kernel_properties.hpp:* {{static assertion failed due to requirement {{.+}}: work_group_size property must only contain non-zero values.}}
+  // expected-error@sycl/ext/oneapi/free_function_kernel_properties.hpp:* {{constexpr variable 'work_group_size<1, 0>' must be initialized by a constant expression}}
   // expected-note@+1 {{in instantiation of variable template specialization 'sycl::ext::oneapi::experimental::work_group_size<1, 0>' requested here}}
   auto WGSize3 = sycl::ext::oneapi::experimental::work_group_size<1, 0>;
-    // expected-error-re@sycl/ext/oneapi/free_function_kernel_properties.hpp:* {{static assertion failed due to requirement {{.+}}: work_group_size property must only contain non-zero values.}}
-    // expected-error@sycl/ext/oneapi/free_function_kernel_properties.hpp:* {{constexpr variable 'work_group_size<0, 1>' must be initialized by a constant expression}}
+  // expected-error-re@sycl/ext/oneapi/free_function_kernel_properties.hpp:* {{static assertion failed due to requirement {{.+}}: work_group_size property must only contain non-zero values.}}
+  // expected-error@sycl/ext/oneapi/free_function_kernel_properties.hpp:* {{constexpr variable 'work_group_size<0, 1>' must be initialized by a constant expression}}
   // expected-note@+1 {{in instantiation of variable template specialization 'sycl::ext::oneapi::experimental::work_group_size<0, 1>' requested here}}
   auto WGSize4 = sycl::ext::oneapi::experimental::work_group_size<0, 1>;
-    // expected-error-re@sycl/ext/oneapi/free_function_kernel_properties.hpp:* {{static assertion failed due to requirement {{.+}}: work_group_size property must only contain non-zero values.}}
-    // expected-error@sycl/ext/oneapi/free_function_kernel_properties.hpp:* {{constexpr variable 'work_group_size<0, 0, 0>' must be initialized by a constant expression}}
+  // expected-error-re@sycl/ext/oneapi/free_function_kernel_properties.hpp:* {{static assertion failed due to requirement {{.+}}: work_group_size property must only contain non-zero values.}}
+  // expected-error@sycl/ext/oneapi/free_function_kernel_properties.hpp:* {{constexpr variable 'work_group_size<0, 0, 0>' must be initialized by a constant expression}}
   // expected-note@+1 {{in instantiation of variable template specialization 'sycl::ext::oneapi::experimental::work_group_size<0, 0, 0>' requested here}}
   auto WGSize5 = sycl::ext::oneapi::experimental::work_group_size<0, 0, 0>;
-    // expected-error-re@sycl/ext/oneapi/free_function_kernel_properties.hpp:* {{static assertion failed due to requirement {{.+}}: work_group_size property must only contain non-zero values.}}
-    // expected-error@sycl/ext/oneapi/free_function_kernel_properties.hpp:* {{constexpr variable 'work_group_size<1, 0, 0>' must be initialized by a constant expression}}
+  // expected-error-re@sycl/ext/oneapi/free_function_kernel_properties.hpp:* {{static assertion failed due to requirement {{.+}}: work_group_size property must only contain non-zero values.}}
+  // expected-error@sycl/ext/oneapi/free_function_kernel_properties.hpp:* {{constexpr variable 'work_group_size<1, 0, 0>' must be initialized by a constant expression}}
   // expected-note@+1 {{in instantiation of variable template specialization 'sycl::ext::oneapi::experimental::work_group_size<1, 0, 0>' requested here}}
   auto WGSize6 = sycl::ext::oneapi::experimental::work_group_size<1, 0, 0>;
-    // expected-error-re@sycl/ext/oneapi/free_function_kernel_properties.hpp:* {{static assertion failed due to requirement {{.+}}: work_group_size property must only contain non-zero values.}}
-    // expected-error@sycl/ext/oneapi/free_function_kernel_properties.hpp:* {{constexpr variable 'work_group_size<0, 1, 0>' must be initialized by a constant expression}}
+  // expected-error-re@sycl/ext/oneapi/free_function_kernel_properties.hpp:* {{static assertion failed due to requirement {{.+}}: work_group_size property must only contain non-zero values.}}
+  // expected-error@sycl/ext/oneapi/free_function_kernel_properties.hpp:* {{constexpr variable 'work_group_size<0, 1, 0>' must be initialized by a constant expression}}
   // expected-note@+1 {{in instantiation of variable template specialization 'sycl::ext::oneapi::experimental::work_group_size<0, 1, 0>' requested here}}
   auto WGSize7 = sycl::ext::oneapi::experimental::work_group_size<0, 1, 0>;
-    // expected-error-re@sycl/ext/oneapi/free_function_kernel_properties.hpp:* {{static assertion failed due to requirement {{.+}}: work_group_size property must only contain non-zero values.}}
-    // expected-error@sycl/ext/oneapi/free_function_kernel_properties.hpp:* {{constexpr variable 'work_group_size<0, 0, 1>' must be initialized by a constant expression}}
+  // expected-error-re@sycl/ext/oneapi/free_function_kernel_properties.hpp:* {{static assertion failed due to requirement {{.+}}: work_group_size property must only contain non-zero values.}}
+  // expected-error@sycl/ext/oneapi/free_function_kernel_properties.hpp:* {{constexpr variable 'work_group_size<0, 0, 1>' must be initialized by a constant expression}}
   // expected-note@+1 {{in instantiation of variable template specialization 'sycl::ext::oneapi::experimental::work_group_size<0, 0, 1>' requested here}}
   auto WGSize8 = sycl::ext::oneapi::experimental::work_group_size<0, 0, 1>;
-    // expected-error-re@sycl/ext/oneapi/free_function_kernel_properties.hpp:* {{static assertion failed due to requirement {{.+}}: work_group_size property must only contain non-zero values.}}
-    // expected-error@sycl/ext/oneapi/free_function_kernel_properties.hpp:* {{constexpr variable 'work_group_size<1, 1, 0>' must be initialized by a constant expression}}
+  // expected-error-re@sycl/ext/oneapi/free_function_kernel_properties.hpp:* {{static assertion failed due to requirement {{.+}}: work_group_size property must only contain non-zero values.}}
+  // expected-error@sycl/ext/oneapi/free_function_kernel_properties.hpp:* {{constexpr variable 'work_group_size<1, 1, 0>' must be initialized by a constant expression}}
   // expected-note@+1 {{in instantiation of variable template specialization 'sycl::ext::oneapi::experimental::work_group_size<1, 1, 0>' requested here}}
   auto WGSize9 = sycl::ext::oneapi::experimental::work_group_size<1, 1, 0>;
-    // expected-error-re@sycl/ext/oneapi/free_function_kernel_properties.hpp:* {{static assertion failed due to requirement {{.+}}: work_group_size property must only contain non-zero values.}}
-    // expected-error@sycl/ext/oneapi/free_function_kernel_properties.hpp:* {{constexpr variable 'work_group_size<0, 1, 1>' must be initialized by a constant expression}}
+  // expected-error-re@sycl/ext/oneapi/free_function_kernel_properties.hpp:* {{static assertion failed due to requirement {{.+}}: work_group_size property must only contain non-zero values.}}
+  // expected-error@sycl/ext/oneapi/free_function_kernel_properties.hpp:* {{constexpr variable 'work_group_size<0, 1, 1>' must be initialized by a constant expression}}
   // expected-note@+1 {{in instantiation of variable template specialization 'sycl::ext::oneapi::experimental::work_group_size<0, 1, 1>' requested here}}
   auto WGSize10 = sycl::ext::oneapi::experimental::work_group_size<0, 1, 1>;
-    // expected-error-re@sycl/ext/oneapi/free_function_kernel_properties.hpp:* {{static assertion failed due to requirement {{.+}}: work_group_size property must only contain non-zero values.}}
-    // expected-error@sycl/ext/oneapi/free_function_kernel_properties.hpp:* {{constexpr variable 'work_group_size<1, 0, 1>' must be initialized by a constant expression}}
+  // expected-error-re@sycl/ext/oneapi/free_function_kernel_properties.hpp:* {{static assertion failed due to requirement {{.+}}: work_group_size property must only contain non-zero values.}}
+  // expected-error@sycl/ext/oneapi/free_function_kernel_properties.hpp:* {{constexpr variable 'work_group_size<1, 0, 1>' must be initialized by a constant expression}}
   // expected-note@+1 {{in instantiation of variable template specialization 'sycl::ext::oneapi::experimental::work_group_size<1, 0, 1>' requested here}}
   auto WGSize11 = sycl::ext::oneapi::experimental::work_group_size<1, 0, 1>;
 
-    // expected-error-re@sycl/ext/oneapi/free_function_kernel_properties.hpp:* {{static assertion failed due to requirement {{.+}}: work_group_size property currently only supports up to three values.}}
-    // expected-error@sycl/ext/oneapi/free_function_kernel_properties.hpp:* {{constexpr variable 'work_group_size<1, 1, 1, 1>' must be initialized by a constant expression}}
+  // expected-error-re@sycl/ext/oneapi/free_function_kernel_properties.hpp:* {{static assertion failed due to requirement {{.+}}: work_group_size property currently only supports up to three values.}}
+  // expected-error@sycl/ext/oneapi/free_function_kernel_properties.hpp:* {{constexpr variable 'work_group_size<1, 1, 1, 1>' must be initialized by a constant expression}}
   // expected-note@+1 {{in instantiation of variable template specialization 'sycl::ext::oneapi::experimental::work_group_size<1, 1, 1, 1>' requested here}}
   auto WGSize12 = sycl::ext::oneapi::experimental::work_group_size<1, 1, 1, 1>;
 
   sycl::queue Q;
 
-    // expected-error-re@sycl/ext/oneapi/properties.hpp:* {{static assertion failed due to requirement {{.+}}: Failed to merge property lists due to conflicting properties.}}
+  // expected-error-re@sycl/ext/oneapi/properties.hpp:* {{static assertion failed due to requirement {{.+}}: Failed to merge property lists due to conflicting properties.}}
   // expected-note-re@+1 {{in instantiation of function template specialization {{.+}}}}
   Q.single_task(
       sycl::ext::oneapi::experimental::properties{
           sycl::ext::oneapi::experimental::work_group_size<1>},
       KernelFunctorWithWGSize<2>{});
 
-    // expected-error-re@sycl/ext/oneapi/properties.hpp:* {{static assertion failed due to requirement {{.+}}: Failed to merge property lists due to conflicting properties.}}
+  // expected-error-re@sycl/ext/oneapi/properties.hpp:* {{static assertion failed due to requirement {{.+}}: Failed to merge property lists due to conflicting properties.}}
   // expected-note-re@+1 {{in instantiation of function template specialization {{.+}}}}
   Q.single_task(
       sycl::ext::oneapi::experimental::properties{
           sycl::ext::oneapi::experimental::work_group_size<1, 1>},
       KernelFunctorWithWGSize<1, 2>{});
 
-    // expected-error-re@sycl/ext/oneapi/properties.hpp:* {{static assertion failed due to requirement {{.+}}: Failed to merge property lists due to conflicting properties.}}
+  // expected-error-re@sycl/ext/oneapi/properties.hpp:* {{static assertion failed due to requirement {{.+}}: Failed to merge property lists due to conflicting properties.}}
   // expected-note-re@+1 {{in instantiation of function template specialization {{.+}}}}
   Q.single_task(
       sycl::ext::oneapi::experimental::properties{
           sycl::ext::oneapi::experimental::work_group_size<1, 1>},
       KernelFunctorWithWGSize<2, 1>{});
 
-    // expected-error-re@sycl/ext/oneapi/properties.hpp:* {{static assertion failed due to requirement {{.+}}: Failed to merge property lists due to conflicting properties.}}
+  // expected-error-re@sycl/ext/oneapi/properties.hpp:* {{static assertion failed due to requirement {{.+}}: Failed to merge property lists due to conflicting properties.}}
   // expected-note-re@+1 {{in instantiation of function template specialization {{.+}}}}
   Q.single_task(
       sycl::ext::oneapi::experimental::properties{
           sycl::ext::oneapi::experimental::work_group_size<1, 1>},
       KernelFunctorWithWGSize<2, 2>{});
 
-    // expected-error-re@sycl/ext/oneapi/properties.hpp:* {{static assertion failed due to requirement {{.+}}: Failed to merge property lists due to conflicting properties.}}
+  // expected-error-re@sycl/ext/oneapi/properties.hpp:* {{static assertion failed due to requirement {{.+}}: Failed to merge property lists due to conflicting properties.}}
   // expected-note-re@+1 {{in instantiation of function template specialization {{.+}}}}
   Q.single_task(
       sycl::ext::oneapi::experimental::properties{
           sycl::ext::oneapi::experimental::work_group_size<1, 1, 1>},
       KernelFunctorWithWGSize<1, 1, 2>{});
 
-    // expected-error-re@sycl/ext/oneapi/properties.hpp:* {{static assertion failed due to requirement {{.+}}: Failed to merge property lists due to conflicting properties.}}
+  // expected-error-re@sycl/ext/oneapi/properties.hpp:* {{static assertion failed due to requirement {{.+}}: Failed to merge property lists due to conflicting properties.}}
   // expected-note-re@+1 {{in instantiation of function template specialization {{.+}}}}
   Q.single_task(
       sycl::ext::oneapi::experimental::properties{
           sycl::ext::oneapi::experimental::work_group_size<1, 1, 1>},
       KernelFunctorWithWGSize<1, 2, 1>{});
 
-    // expected-error-re@sycl/ext/oneapi/properties.hpp:* {{static assertion failed due to requirement {{.+}}: Failed to merge property lists due to conflicting properties.}}
+  // expected-error-re@sycl/ext/oneapi/properties.hpp:* {{static assertion failed due to requirement {{.+}}: Failed to merge property lists due to conflicting properties.}}
   // expected-note-re@+1 {{in instantiation of function template specialization {{.+}}}}
   Q.single_task(
       sycl::ext::oneapi::experimental::properties{
           sycl::ext::oneapi::experimental::work_group_size<1, 1, 1>},
       KernelFunctorWithWGSize<2, 1, 1>{});
 
-    // expected-error-re@sycl/ext/oneapi/properties.hpp:* {{static assertion failed due to requirement {{.+}}: Failed to merge property lists due to conflicting properties.}}
+  // expected-error-re@sycl/ext/oneapi/properties.hpp:* {{static assertion failed due to requirement {{.+}}: Failed to merge property lists due to conflicting properties.}}
   // expected-note-re@+1 {{in instantiation of function template specialization {{.+}}}}
   Q.single_task(
       sycl::ext::oneapi::experimental::properties{
           sycl::ext::oneapi::experimental::work_group_size<1, 1, 1>},
       KernelFunctorWithWGSize<1, 2, 2>{});
 
-    // expected-error-re@sycl/ext/oneapi/properties.hpp:* {{static assertion failed due to requirement {{.+}}: Failed to merge property lists due to conflicting properties.}}
+  // expected-error-re@sycl/ext/oneapi/properties.hpp:* {{static assertion failed due to requirement {{.+}}: Failed to merge property lists due to conflicting properties.}}
   // expected-note-re@+1 {{in instantiation of function template specialization {{.+}}}}
   Q.single_task(
       sycl::ext::oneapi::experimental::properties{
           sycl::ext::oneapi::experimental::work_group_size<1, 1, 1>},
       KernelFunctorWithWGSize<2, 2, 1>{});
 
-    // expected-error-re@sycl/ext/oneapi/properties.hpp:* {{static assertion failed due to requirement {{.+}}: Failed to merge property lists due to conflicting properties.}}
+  // expected-error-re@sycl/ext/oneapi/properties.hpp:* {{static assertion failed due to requirement {{.+}}: Failed to merge property lists due to conflicting properties.}}
   // expected-note-re@+1 {{in instantiation of function template specialization {{.+}}}}
   Q.single_task(
       sycl::ext::oneapi::experimental::properties{
           sycl::ext::oneapi::experimental::work_group_size<1, 1, 1>},
       KernelFunctorWithWGSize<2, 1, 2>{});
 
-    // expected-error-re@sycl/ext/oneapi/properties.hpp:* {{static assertion failed due to requirement {{.+}}: Failed to merge property lists due to conflicting properties.}}
+  // expected-error-re@sycl/ext/oneapi/properties.hpp:* {{static assertion failed due to requirement {{.+}}: Failed to merge property lists due to conflicting properties.}}
   // expected-note-re@+1 {{in instantiation of function template specialization {{.+}}}}
   Q.single_task(
       sycl::ext::oneapi::experimental::properties{
@@ -164,90 +164,90 @@ void check_work_group_size_hint() {
   // expected-error@+1 {{too few template arguments for variable template 'work_group_size_hint'}}
   auto WGSize0 = sycl::ext::oneapi::experimental::work_group_size_hint<>;
 
-    // expected-error-re@sycl/ext/oneapi/free_function_kernel_properties.hpp:* {{static assertion failed due to requirement {{.+}}: work_group_size_hint property must only contain non-zero values.}}
-    // expected-error@sycl/ext/oneapi/free_function_kernel_properties.hpp:* {{constexpr variable 'work_group_size_hint<0>' must be initialized by a constant expression}}
+  // expected-error-re@sycl/ext/oneapi/free_function_kernel_properties.hpp:* {{static assertion failed due to requirement {{.+}}: work_group_size_hint property must only contain non-zero values.}}
+  // expected-error@sycl/ext/oneapi/free_function_kernel_properties.hpp:* {{constexpr variable 'work_group_size_hint<0>' must be initialized by a constant expression}}
   // expected-note@+1 {{in instantiation of variable template specialization 'sycl::ext::oneapi::experimental::work_group_size_hint<0>' requested here}}
   auto WGSize1 = sycl::ext::oneapi::experimental::work_group_size_hint<0>;
-    // expected-error-re@sycl/ext/oneapi/free_function_kernel_properties.hpp:* {{static assertion failed due to requirement {{.+}}: work_group_size_hint property must only contain non-zero values.}}
-    // expected-error@sycl/ext/oneapi/free_function_kernel_properties.hpp:* {{constexpr variable 'work_group_size_hint<0, 0>' must be initialized by a constant expression}}
+  // expected-error-re@sycl/ext/oneapi/free_function_kernel_properties.hpp:* {{static assertion failed due to requirement {{.+}}: work_group_size_hint property must only contain non-zero values.}}
+  // expected-error@sycl/ext/oneapi/free_function_kernel_properties.hpp:* {{constexpr variable 'work_group_size_hint<0, 0>' must be initialized by a constant expression}}
   // expected-note@+1 {{in instantiation of variable template specialization 'sycl::ext::oneapi::experimental::work_group_size_hint<0, 0>' requested here}}
   auto WGSize2 = sycl::ext::oneapi::experimental::work_group_size_hint<0, 0>;
-    // expected-error-re@sycl/ext/oneapi/free_function_kernel_properties.hpp:* {{static assertion failed due to requirement {{.+}}: work_group_size_hint property must only contain non-zero values.}}
-    // expected-error@sycl/ext/oneapi/free_function_kernel_properties.hpp:* {{constexpr variable 'work_group_size_hint<1, 0>' must be initialized by a constant expression}}
+  // expected-error-re@sycl/ext/oneapi/free_function_kernel_properties.hpp:* {{static assertion failed due to requirement {{.+}}: work_group_size_hint property must only contain non-zero values.}}
+  // expected-error@sycl/ext/oneapi/free_function_kernel_properties.hpp:* {{constexpr variable 'work_group_size_hint<1, 0>' must be initialized by a constant expression}}
   // expected-note@+1 {{in instantiation of variable template specialization 'sycl::ext::oneapi::experimental::work_group_size_hint<1, 0>' requested here}}
   auto WGSize3 = sycl::ext::oneapi::experimental::work_group_size_hint<1, 0>;
-    // expected-error-re@sycl/ext/oneapi/free_function_kernel_properties.hpp:* {{static assertion failed due to requirement {{.+}}: work_group_size_hint property must only contain non-zero values.}}
-    // expected-error@sycl/ext/oneapi/free_function_kernel_properties.hpp:* {{constexpr variable 'work_group_size_hint<0, 1>' must be initialized by a constant expression}}
+  // expected-error-re@sycl/ext/oneapi/free_function_kernel_properties.hpp:* {{static assertion failed due to requirement {{.+}}: work_group_size_hint property must only contain non-zero values.}}
+  // expected-error@sycl/ext/oneapi/free_function_kernel_properties.hpp:* {{constexpr variable 'work_group_size_hint<0, 1>' must be initialized by a constant expression}}
   // expected-note@+1 {{in instantiation of variable template specialization 'sycl::ext::oneapi::experimental::work_group_size_hint<0, 1>' requested here}}
   auto WGSize4 = sycl::ext::oneapi::experimental::work_group_size_hint<0, 1>;
-    // expected-error-re@sycl/ext/oneapi/free_function_kernel_properties.hpp:* {{static assertion failed due to requirement {{.+}}: work_group_size_hint property must only contain non-zero values.}}
-    // expected-error@sycl/ext/oneapi/free_function_kernel_properties.hpp:* {{constexpr variable 'work_group_size_hint<0, 0, 0>' must be initialized by a constant expression}}
+  // expected-error-re@sycl/ext/oneapi/free_function_kernel_properties.hpp:* {{static assertion failed due to requirement {{.+}}: work_group_size_hint property must only contain non-zero values.}}
+  // expected-error@sycl/ext/oneapi/free_function_kernel_properties.hpp:* {{constexpr variable 'work_group_size_hint<0, 0, 0>' must be initialized by a constant expression}}
   // expected-note@+1 {{in instantiation of variable template specialization 'sycl::ext::oneapi::experimental::work_group_size_hint<0, 0, 0>' requested here}}
   auto WGSize5 = sycl::ext::oneapi::experimental::work_group_size_hint<0, 0, 0>;
-    // expected-error-re@sycl/ext/oneapi/free_function_kernel_properties.hpp:* {{static assertion failed due to requirement {{.+}}: work_group_size_hint property must only contain non-zero values.}}
-    // expected-error@sycl/ext/oneapi/free_function_kernel_properties.hpp:* {{constexpr variable 'work_group_size_hint<1, 0, 0>' must be initialized by a constant expression}}
+  // expected-error-re@sycl/ext/oneapi/free_function_kernel_properties.hpp:* {{static assertion failed due to requirement {{.+}}: work_group_size_hint property must only contain non-zero values.}}
+  // expected-error@sycl/ext/oneapi/free_function_kernel_properties.hpp:* {{constexpr variable 'work_group_size_hint<1, 0, 0>' must be initialized by a constant expression}}
   // expected-note@+1 {{in instantiation of variable template specialization 'sycl::ext::oneapi::experimental::work_group_size_hint<1, 0, 0>' requested here}}
   auto WGSize6 = sycl::ext::oneapi::experimental::work_group_size_hint<1, 0, 0>;
-    // expected-error-re@sycl/ext/oneapi/free_function_kernel_properties.hpp:* {{static assertion failed due to requirement {{.+}}: work_group_size_hint property must only contain non-zero values.}}
-    // expected-error@sycl/ext/oneapi/free_function_kernel_properties.hpp:* {{constexpr variable 'work_group_size_hint<0, 1, 0>' must be initialized by a constant expression}}
+  // expected-error-re@sycl/ext/oneapi/free_function_kernel_properties.hpp:* {{static assertion failed due to requirement {{.+}}: work_group_size_hint property must only contain non-zero values.}}
+  // expected-error@sycl/ext/oneapi/free_function_kernel_properties.hpp:* {{constexpr variable 'work_group_size_hint<0, 1, 0>' must be initialized by a constant expression}}
   // expected-note@+1 {{in instantiation of variable template specialization 'sycl::ext::oneapi::experimental::work_group_size_hint<0, 1, 0>' requested here}}
   auto WGSize7 = sycl::ext::oneapi::experimental::work_group_size_hint<0, 1, 0>;
-    // expected-error-re@sycl/ext/oneapi/free_function_kernel_properties.hpp:* {{static assertion failed due to requirement {{.+}}: work_group_size_hint property must only contain non-zero values.}}
-    // expected-error@sycl/ext/oneapi/free_function_kernel_properties.hpp:* {{constexpr variable 'work_group_size_hint<0, 0, 1>' must be initialized by a constant expression}}
+  // expected-error-re@sycl/ext/oneapi/free_function_kernel_properties.hpp:* {{static assertion failed due to requirement {{.+}}: work_group_size_hint property must only contain non-zero values.}}
+  // expected-error@sycl/ext/oneapi/free_function_kernel_properties.hpp:* {{constexpr variable 'work_group_size_hint<0, 0, 1>' must be initialized by a constant expression}}
   // expected-note@+1 {{in instantiation of variable template specialization 'sycl::ext::oneapi::experimental::work_group_size_hint<0, 0, 1>' requested here}}
   auto WGSize8 = sycl::ext::oneapi::experimental::work_group_size_hint<0, 0, 1>;
-    // expected-error-re@sycl/ext/oneapi/free_function_kernel_properties.hpp:* {{static assertion failed due to requirement {{.+}}: work_group_size_hint property must only contain non-zero values.}}
-    // expected-error@sycl/ext/oneapi/free_function_kernel_properties.hpp:* {{constexpr variable 'work_group_size_hint<1, 1, 0>' must be initialized by a constant expression}}
+  // expected-error-re@sycl/ext/oneapi/free_function_kernel_properties.hpp:* {{static assertion failed due to requirement {{.+}}: work_group_size_hint property must only contain non-zero values.}}
+  // expected-error@sycl/ext/oneapi/free_function_kernel_properties.hpp:* {{constexpr variable 'work_group_size_hint<1, 1, 0>' must be initialized by a constant expression}}
   // expected-note@+1 {{in instantiation of variable template specialization 'sycl::ext::oneapi::experimental::work_group_size_hint<1, 1, 0>' requested here}}
   auto WGSize9 = sycl::ext::oneapi::experimental::work_group_size_hint<1, 1, 0>;
-    // expected-error-re@sycl/ext/oneapi/free_function_kernel_properties.hpp:* {{static assertion failed due to requirement {{.+}}: work_group_size_hint property must only contain non-zero values.}}
-    // expected-error@sycl/ext/oneapi/free_function_kernel_properties.hpp:* {{constexpr variable 'work_group_size_hint<0, 1, 1>' must be initialized by a constant expression}}
+  // expected-error-re@sycl/ext/oneapi/free_function_kernel_properties.hpp:* {{static assertion failed due to requirement {{.+}}: work_group_size_hint property must only contain non-zero values.}}
+  // expected-error@sycl/ext/oneapi/free_function_kernel_properties.hpp:* {{constexpr variable 'work_group_size_hint<0, 1, 1>' must be initialized by a constant expression}}
   // expected-note@+2 {{in instantiation of variable template specialization 'sycl::ext::oneapi::experimental::work_group_size_hint<0, 1, 1>' requested here}}
   auto WGSize10 =
       sycl::ext::oneapi::experimental::work_group_size_hint<0, 1, 1>;
-    // expected-error-re@sycl/ext/oneapi/free_function_kernel_properties.hpp:* {{static assertion failed due to requirement {{.+}}: work_group_size_hint property must only contain non-zero values.}}
-    // expected-error@sycl/ext/oneapi/free_function_kernel_properties.hpp:* {{constexpr variable 'work_group_size_hint<1, 0, 1>' must be initialized by a constant expression}}
+  // expected-error-re@sycl/ext/oneapi/free_function_kernel_properties.hpp:* {{static assertion failed due to requirement {{.+}}: work_group_size_hint property must only contain non-zero values.}}
+  // expected-error@sycl/ext/oneapi/free_function_kernel_properties.hpp:* {{constexpr variable 'work_group_size_hint<1, 0, 1>' must be initialized by a constant expression}}
   // expected-note@+2 {{in instantiation of variable template specialization 'sycl::ext::oneapi::experimental::work_group_size_hint<1, 0, 1>' requested here}}
   auto WGSize11 =
       sycl::ext::oneapi::experimental::work_group_size_hint<1, 0, 1>;
 
-    // expected-error-re@sycl/ext/oneapi/free_function_kernel_properties.hpp:* {{static assertion failed due to requirement {{.+}}: work_group_size_hint property currently only supports up to three values.}}
-    // expected-error@sycl/ext/oneapi/free_function_kernel_properties.hpp:* {{constexpr variable 'work_group_size_hint<1, 1, 1, 1>' must be initialized by a constant expression}}
+  // expected-error-re@sycl/ext/oneapi/free_function_kernel_properties.hpp:* {{static assertion failed due to requirement {{.+}}: work_group_size_hint property currently only supports up to three values.}}
+  // expected-error@sycl/ext/oneapi/free_function_kernel_properties.hpp:* {{constexpr variable 'work_group_size_hint<1, 1, 1, 1>' must be initialized by a constant expression}}
   // expected-note@+2 {{in instantiation of variable template specialization 'sycl::ext::oneapi::experimental::work_group_size_hint<1, 1, 1, 1>' requested here}}
   auto WGSize12 =
       sycl::ext::oneapi::experimental::work_group_size_hint<1, 1, 1, 1>;
 
   sycl::queue Q;
 
-    // expected-error-re@sycl/ext/oneapi/properties.hpp:* {{static assertion failed due to requirement {{.+}}: Failed to merge property lists due to conflicting properties.}}
+  // expected-error-re@sycl/ext/oneapi/properties.hpp:* {{static assertion failed due to requirement {{.+}}: Failed to merge property lists due to conflicting properties.}}
   // expected-note-re@+1 {{in instantiation of function template specialization {{.+}}}}
   Q.single_task(
       sycl::ext::oneapi::experimental::properties{
           sycl::ext::oneapi::experimental::work_group_size_hint<1>},
       KernelFunctorWithWGSizeHint<2>{});
 
-    // expected-error-re@sycl/ext/oneapi/properties.hpp:* {{static assertion failed due to requirement {{.+}}: Failed to merge property lists due to conflicting properties.}}
+  // expected-error-re@sycl/ext/oneapi/properties.hpp:* {{static assertion failed due to requirement {{.+}}: Failed to merge property lists due to conflicting properties.}}
   // expected-note-re@+1 {{in instantiation of function template specialization {{.+}}}}
   Q.single_task(
       sycl::ext::oneapi::experimental::properties{
           sycl::ext::oneapi::experimental::work_group_size_hint<1, 1>},
       KernelFunctorWithWGSizeHint<1, 2>{});
 
-    // expected-error-re@sycl/ext/oneapi/properties.hpp:* {{static assertion failed due to requirement {{.+}}: Failed to merge property lists due to conflicting properties.}}
+  // expected-error-re@sycl/ext/oneapi/properties.hpp:* {{static assertion failed due to requirement {{.+}}: Failed to merge property lists due to conflicting properties.}}
   // expected-note-re@+1 {{in instantiation of function template specialization {{.+}}}}
   Q.single_task(
       sycl::ext::oneapi::experimental::properties{
           sycl::ext::oneapi::experimental::work_group_size_hint<1, 1>},
       KernelFunctorWithWGSizeHint<2, 1>{});
 
-    // expected-error-re@sycl/ext/oneapi/properties.hpp:* {{static assertion failed due to requirement {{.+}}: Failed to merge property lists due to conflicting properties.}}
+  // expected-error-re@sycl/ext/oneapi/properties.hpp:* {{static assertion failed due to requirement {{.+}}: Failed to merge property lists due to conflicting properties.}}
   // expected-note-re@+1 {{in instantiation of function template specialization {{.+}}}}
   Q.single_task(
       sycl::ext::oneapi::experimental::properties{
           sycl::ext::oneapi::experimental::work_group_size_hint<1, 1>},
       KernelFunctorWithWGSizeHint<2, 2>{});
 
-    // expected-error-re@sycl/ext/oneapi/properties.hpp:* {{static assertion failed due to requirement {{.+}}: Failed to merge property lists due to conflicting properties.}}
+  // expected-error-re@sycl/ext/oneapi/properties.hpp:* {{static assertion failed due to requirement {{.+}}: Failed to merge property lists due to conflicting properties.}}
   // expected-note-re@+1 {{in instantiation of function template specialization {{.+}}}}
   Q.single_task(
       sycl::ext::oneapi::experimental::properties{
@@ -301,14 +301,14 @@ void check_sub_group_size() {
   // expected-error@+1 {{too few template arguments for variable template 'sub_group_size'}}
   auto WGSize0 = sycl::ext::oneapi::experimental::sub_group_size<>;
 
-    // expected-error-re@sycl/ext/oneapi/free_function_kernel_properties.hpp:* {{static assertion failed due to requirement {{.+}}: sub_group_size property must contain a non-zero value.}}
-    // expected-error@sycl/ext/oneapi/free_function_kernel_properties.hpp:* {{constexpr variable 'sub_group_size<0>' must be initialized by a constant expression}}
+  // expected-error-re@sycl/ext/oneapi/free_function_kernel_properties.hpp:* {{static assertion failed due to requirement {{.+}}: sub_group_size property must contain a non-zero value.}}
+  // expected-error@sycl/ext/oneapi/free_function_kernel_properties.hpp:* {{constexpr variable 'sub_group_size<0>' must be initialized by a constant expression}}
   // expected-note@+1 {{in instantiation of variable template specialization 'sycl::ext::oneapi::experimental::sub_group_size<0>' requested here}}
   auto WGSize1 = sycl::ext::oneapi::experimental::sub_group_size<0>;
 
   sycl::queue Q;
 
-    // expected-error-re@sycl/ext/oneapi/properties.hpp:* {{static assertion failed due to requirement {{.+}}: Failed to merge property lists due to conflicting properties.}}
+  // expected-error-re@sycl/ext/oneapi/properties.hpp:* {{static assertion failed due to requirement {{.+}}: Failed to merge property lists due to conflicting properties.}}
   // expected-note-re@+1 {{in instantiation of function template specialization {{.+}}}}
   Q.single_task(
       sycl::ext::oneapi::experimental::properties{
@@ -319,28 +319,28 @@ void check_sub_group_size() {
 void check_max_work_group_size() {
   sycl::queue Q;
 
-    // expected-error-re@sycl/detail/kernel_launch_helper.hpp:* {{static assertion failed due to requirement {{.+}}: work_group_size and max_work_group_size dimensionality must match}}
+  // expected-error-re@sycl/detail/kernel_launch_helper.hpp:* {{static assertion failed due to requirement {{.+}}: work_group_size and max_work_group_size dimensionality must match}}
   Q.single_task(
       sycl::ext::oneapi::experimental::properties{
           sycl::ext::oneapi::experimental::work_group_size<2, 2>,
           sycl::ext::oneapi::experimental::max_work_group_size<1>},
       []() {});
 
-    // expected-error-re@sycl/detail/kernel_launch_helper.hpp:* {{static assertion failed due to requirement {{.+}}: work_group_size must not exceed max_work_group_size}}
+  // expected-error-re@sycl/detail/kernel_launch_helper.hpp:* {{static assertion failed due to requirement {{.+}}: work_group_size must not exceed max_work_group_size}}
   Q.single_task(
       sycl::ext::oneapi::experimental::properties{
           sycl::ext::oneapi::experimental::work_group_size<2>,
           sycl::ext::oneapi::experimental::max_work_group_size<1>},
       []() {});
 
-    // expected-error-re@sycl/detail/kernel_launch_helper.hpp:* {{static assertion failed due to requirement {{.+}}: work_group_size must not exceed max_work_group_size}}
+  // expected-error-re@sycl/detail/kernel_launch_helper.hpp:* {{static assertion failed due to requirement {{.+}}: work_group_size must not exceed max_work_group_size}}
   Q.single_task(
       sycl::ext::oneapi::experimental::properties{
           sycl::ext::oneapi::experimental::work_group_size<2, 2>,
           sycl::ext::oneapi::experimental::max_work_group_size<2, 1>},
       []() {});
 
-    // expected-error-re@sycl/detail/kernel_launch_helper.hpp:* {{static assertion failed due to requirement {{.+}}: work_group_size must not exceed max_work_group_size}}
+  // expected-error-re@sycl/detail/kernel_launch_helper.hpp:* {{static assertion failed due to requirement {{.+}}: work_group_size must not exceed max_work_group_size}}
   Q.single_task(
       sycl::ext::oneapi::experimental::properties{
           sycl::ext::oneapi::experimental::work_group_size<2, 2, 2>,
@@ -351,21 +351,21 @@ void check_max_work_group_size() {
 void check_max_linear_work_group_size() {
   sycl::queue Q;
 
-    // expected-error-re@sycl/detail/kernel_launch_helper.hpp:* {{static assertion failed due to requirement {{.+}}: work_group_size must not exceed max_linear_work_group_size}}
+  // expected-error-re@sycl/detail/kernel_launch_helper.hpp:* {{static assertion failed due to requirement {{.+}}: work_group_size must not exceed max_linear_work_group_size}}
   Q.single_task(
       sycl::ext::oneapi::experimental::properties{
           sycl::ext::oneapi::experimental::work_group_size<2>,
           sycl::ext::oneapi::experimental::max_linear_work_group_size<1>},
       []() {});
 
-    // expected-error-re@sycl/detail/kernel_launch_helper.hpp:* {{static assertion failed due to requirement {{.+}}: work_group_size must not exceed max_linear_work_group_size}}
+  // expected-error-re@sycl/detail/kernel_launch_helper.hpp:* {{static assertion failed due to requirement {{.+}}: work_group_size must not exceed max_linear_work_group_size}}
   Q.single_task(
       sycl::ext::oneapi::experimental::properties{
           sycl::ext::oneapi::experimental::work_group_size<2, 4>,
           sycl::ext::oneapi::experimental::max_linear_work_group_size<7>},
       []() {});
 
-    // expected-error-re@sycl/detail/kernel_launch_helper.hpp:* {{static assertion failed due to requirement {{.+}}: work_group_size must not exceed max_linear_work_group_size}}
+  // expected-error-re@sycl/detail/kernel_launch_helper.hpp:* {{static assertion failed due to requirement {{.+}}: work_group_size must not exceed max_linear_work_group_size}}
   Q.single_task(
       sycl::ext::oneapi::experimental::properties{
           sycl::ext::oneapi::experimental::work_group_size<2, 4, 2>,

From b4ecf69e28fe0ab47dc7a9d0640e7b24152a54c5 Mon Sep 17 00:00:00 2001
From: y <konstantinos.parasyris@intel.com>
Date: Mon, 27 Apr 2026 14:16:48 -0700
Subject: [PATCH 06/11] Add tests

---
 .../properties/properties_compat.cpp          | 25 +++++++++++++++++++
 1 file changed, 25 insertions(+)
 create mode 100644 sycl/test/extensions/properties/properties_compat.cpp

diff --git a/sycl/test/extensions/properties/properties_compat.cpp b/sycl/test/extensions/properties/properties_compat.cpp
new file mode 100644
index 0000000000000..379fdb95b1d65
--- /dev/null
+++ b/sycl/test/extensions/properties/properties_compat.cpp
@@ -0,0 +1,25 @@
+// RUN: %clangxx -fsycl -fsyntax-only -I %sycl_source_dir/include -I %sycl_include %s
+// expected-no-diagnostics
+
+#include <sycl/ext/oneapi/properties/properties.hpp>
+
+#include <cstdint>
+#include "mock_compile_time_properties.hpp"
+
+#include <type_traits>
+
+using namespace sycl::ext::oneapi::experimental;
+
+int main() {
+  constexpr auto Props = properties{bar, baz<1>, foo{42}};
+
+  static_assert(is_property_list_v<std::remove_cv_t<decltype(Props)>>);
+  static_assert(decltype(Props)::has_property<bar_key>());
+  static_assert(decltype(Props)::has_property<baz_key>());
+  static_assert(decltype(Props)::has_property<foo_key>());
+  static_assert(std::is_same_v<decltype(Props.get_property<baz_key>()),
+                               baz_key::value_t<1>>);
+  static_assert(Props.get_property<foo_key>().value == 42);
+
+  return 0;
+}
\ No newline at end of file

From a24da7c67bccd22f3064c7ad8fa143decc3874e0 Mon Sep 17 00:00:00 2001
From: y <konstantinos.parasyris@intel.com>
Date: Mon, 27 Apr 2026 14:21:52 -0700
Subject: [PATCH 07/11] Format

---
 ..._ext_oneapi_free_function_kernels.asciidoc | 13 ++++++-----
 ...sycl_ext_oneapi_kernel_properties.asciidoc | 23 ++++++++++---------
 .../properties/properties_compat.cpp          |  2 +-
 3 files changed, 20 insertions(+), 18 deletions(-)

diff --git a/sycl/doc/extensions/experimental/sycl_ext_oneapi_free_function_kernels.asciidoc b/sycl/doc/extensions/experimental/sycl_ext_oneapi_free_function_kernels.asciidoc
index 4c972bec21738..8c92cde24c37d 100644
--- a/sycl/doc/extensions/experimental/sycl_ext_oneapi_free_function_kernels.asciidoc
+++ b/sycl/doc/extensions/experimental/sycl_ext_oneapi_free_function_kernels.asciidoc
@@ -125,8 +125,8 @@ choice of headers depending on which properties they need:
   `work_group_size_hint`, `sub_group_size`, `max_work_group_size`, and
   `max_linear_work_group_size`.
 
-* `#include <sycl/ext/oneapi/kernel_properties.hpp>` provides the
-  full kernel properties interface, including property lists such as
+* `#include <sycl/ext/oneapi/kernel_properties.hpp>` currently provides the
+  broader kernel properties interface, including property lists such as
   `properties{...}` and embedded kernel properties via `properties_tag`.
 
 Applications may include the umbrella header in all cases. The lightweight
@@ -134,8 +134,9 @@ header is intended for code that defines free-function kernels and only needs
 the free-function annotation path.
 
 Code that forms property lists such as `properties{...}`, uses
-`properties_tag`, or depends on the umbrella property's property-list conflict
-checks should include `sycl/ext/oneapi/kernel_properties.hpp`.
+`properties_tag`, or otherwise needs the broader kernel-properties interface
+will generally find `sycl/ext/oneapi/kernel_properties.hpp` to be the more
+convenient header to include.
 
 === Defining a free function kernel
 
@@ -832,8 +833,8 @@ In the {dpcpp} implementation, code that defines free-function kernels may
 include `sycl/ext/oneapi/free_function_kernel_properties.hpp` instead of the
 full `sycl/ext/oneapi/kernel_properties.hpp` header when it only needs the
 free-function annotation path. Applications that use property-list semantics,
-including `properties{...}`, `properties_tag`, or the associated
-property-list conflict checks, should include the umbrella header.
+including `properties{...}` or `properties_tag`, will generally prefer the
+umbrella header.
 
 ```
 SYCL_EXT_ONEAPI_FUNCTION_PROPERTY((syclexp::nd_range_kernel<1>))
diff --git a/sycl/doc/extensions/experimental/sycl_ext_oneapi_kernel_properties.asciidoc b/sycl/doc/extensions/experimental/sycl_ext_oneapi_kernel_properties.asciidoc
index 4b40180c4180e..7acc31379f388 100644
--- a/sycl/doc/extensions/experimental/sycl_ext_oneapi_kernel_properties.asciidoc
+++ b/sycl/doc/extensions/experimental/sycl_ext_oneapi_kernel_properties.asciidoc
@@ -117,17 +117,17 @@ supports.
 
 === Headers
 
-In the {dpcpp} implementation, the full API described in this extension is
-provided by:
+In the current {dpcpp} implementation, the APIs described in this extension
+are organized as follows:
 
 * `#include <sycl/ext/oneapi/kernel_properties.hpp>`
 
-This umbrella header should be used when code needs property lists such as
-`properties{...}`, embedded kernel properties via `properties_tag`, or any of
-the non-launch kernel properties described in this extension.
+This umbrella header is the most direct choice when code needs property lists
+such as `properties{...}`, embedded kernel properties via `properties_tag`, or
+any of the non-launch kernel properties described in this extension.
 
-The implementation also provides lighter-weight headers for code that only
-needs free-function annotations:
+The implementation also currently provides lighter-weight headers for code
+that only needs free-function annotations:
 
 * `#include <sycl/ext/oneapi/free_function_kernel_properties.hpp>` for
   `nd_range_kernel<Dims>`, `single_task_kernel`,
@@ -139,10 +139,11 @@ needs free-function annotations:
 These lighter-weight headers are primarily intended for code paths where
 reduced compile time is a high priority and the application only needs
 function-level annotations.
-The `sycl/ext/oneapi/free_function_kernel_properties.hpp` header is intended
-for the free-function kernel definition path. Code that forms property lists,
-uses `properties_tag`, or depends on the umbrella property's property-list
-conflict checks should include `sycl/ext/oneapi/kernel_properties.hpp`.
+The `sycl/ext/oneapi/free_function_kernel_properties.hpp` header is aimed at
+the free-function kernel definition path. Code that forms property lists or
+uses `properties_tag` will generally find
+`sycl/ext/oneapi/kernel_properties.hpp` to be the more natural header to
+include.
 
 === Kernel Properties
 
diff --git a/sycl/test/extensions/properties/properties_compat.cpp b/sycl/test/extensions/properties/properties_compat.cpp
index 379fdb95b1d65..9f3f11b69e1f5 100644
--- a/sycl/test/extensions/properties/properties_compat.cpp
+++ b/sycl/test/extensions/properties/properties_compat.cpp
@@ -3,8 +3,8 @@
 
 #include <sycl/ext/oneapi/properties/properties.hpp>
 
-#include <cstdint>
 #include "mock_compile_time_properties.hpp"
+#include <cstdint>
 
 #include <type_traits>
 

From 99a07158d80ff70cd72e494f9f591814873f58bf Mon Sep 17 00:00:00 2001
From: y <konstantinos.parasyris@intel.com>
Date: Mon, 27 Apr 2026 17:10:59 -0700
Subject: [PATCH 08/11] Fix CI

Co-authored-by: Copilot <copilot@github.com>
---
 .../extensions/properties/mock_compile_time_properties.hpp | 7 +++----
 1 file changed, 3 insertions(+), 4 deletions(-)

diff --git a/sycl/test/extensions/properties/mock_compile_time_properties.hpp b/sycl/test/extensions/properties/mock_compile_time_properties.hpp
index 6d167d7c8ecf9..8eb830256a873 100644
--- a/sycl/test/extensions/properties/mock_compile_time_properties.hpp
+++ b/sycl/test/extensions/properties/mock_compile_time_properties.hpp
@@ -12,6 +12,8 @@
 
 #pragma once
 
+#include <cstdint>
+
 namespace sycl {
 namespace ext {
 namespace oneapi {
@@ -47,10 +49,7 @@ inline bool operator!=(const foo &lhs, const foo &rhs) { return !(lhs == rhs); }
 struct foz : detail::run_time_property_key<foz, fakePropKind(4)> {
   constexpr foz(float v1, bool v2) : value1(v1), value2(v2) {}
   // Define copy constructor to make foz non-trivially copyable
-  constexpr foz(const foz &f) {
-    value1 = f.value1;
-    value2 = f.value2;
-  }
+  constexpr foz(const foz &f) : value1(f.value1), value2(f.value2) {}
   float value1;
   bool value2;
 };

From 35ccc96071b318d528e41c932d157bdab08563e1 Mon Sep 17 00:00:00 2001
From: y <konstantinos.parasyris@intel.com>
Date: Mon, 11 May 2026 08:28:16 -0700
Subject: [PATCH 09/11] Address wording

---
 ..._ext_oneapi_free_function_kernels.asciidoc | 48 +++++++------------
 ...sycl_ext_oneapi_kernel_properties.asciidoc | 42 ++++++----------
 2 files changed, 33 insertions(+), 57 deletions(-)

diff --git a/sycl/doc/extensions/experimental/sycl_ext_oneapi_free_function_kernels.asciidoc b/sycl/doc/extensions/experimental/sycl_ext_oneapi_free_function_kernels.asciidoc
index 8c92cde24c37d..b887543142ec5 100644
--- a/sycl/doc/extensions/experimental/sycl_ext_oneapi_free_function_kernels.asciidoc
+++ b/sycl/doc/extensions/experimental/sycl_ext_oneapi_free_function_kernels.asciidoc
@@ -114,29 +114,22 @@ supports.
 
 === Headers
 
-In the {dpcpp} implementation, applications that use this extension have a
-choice of headers depending on which properties they need:
-
-* `#include <sycl/ext/oneapi/free_function_kernel_properties.hpp>` is
-  sufficient for `SYCL_EXT_ONEAPI_FUNCTION_PROPERTY`,
-  `nd_range_kernel<Dims>`, `single_task_kernel`, and the standalone
-  compile-time kernel properties that may be applied directly to a free
-  function kernel declaration, such as `work_group_size`,
-  `work_group_size_hint`, `sub_group_size`, `max_work_group_size`, and
-  `max_linear_work_group_size`.
-
-* `#include <sycl/ext/oneapi/kernel_properties.hpp>` currently provides the
-  broader kernel properties interface, including property lists such as
-  `properties{...}` and embedded kernel properties via `properties_tag`.
-
-Applications may include the umbrella header in all cases. The lightweight
-header is intended for code that defines free-function kernels and only needs
-the free-function annotation path.
-
-Code that forms property lists such as `properties{...}`, uses
-`properties_tag`, or otherwise needs the broader kernel-properties interface
-will generally find `sycl/ext/oneapi/kernel_properties.hpp` to be the more
-convenient header to include.
+The APIs defined in this extension are provided by either of the following header files:
+
+* `<sycl/sycl.hpp>`
+* `<sycl/ext/oneapi/kernel_properties.hpp>`
+
+In addition, the following lightweight header provides a subset of the APIs from this extension:
+
+* `<sycl/ext/oneapi/free_function_kernel_properties.hpp>`
+
+This lightweight header provides `SYCL_EXT_ONEAPI_FUNCTION_PROPERTY`, and the
+properties `nd_range_kernel<Dims>` and `single_task_kernel`.  See
+link:../experimental/sycl_ext_oneapi_kernel_properties.asciidoc[
+sycl_ext_oneapi_kernel_properties] for other APIs that are provided by this
+header.
+
+[_Note:_ The lightweight header is intended for cases where fast compilation time is a priority. -- _end note_]
 
 === Defining a free function kernel
 
@@ -829,14 +822,9 @@ in link:../experimental/sycl_ext_oneapi_kernel_properties.asciidoc[
 sycl_ext_oneapi_kernel_properties] by applying the properties to the function
 declaration as illustrated below.
 
-In the {dpcpp} implementation, code that defines free-function kernels may
-include `sycl/ext/oneapi/free_function_kernel_properties.hpp` instead of the
-full `sycl/ext/oneapi/kernel_properties.hpp` header when it only needs the
-free-function annotation path. Applications that use property-list semantics,
-including `properties{...}` or `properties_tag`, will generally prefer the
-umbrella header.
-
 ```
+#include <sycl/ext/oneapi/kernel_properties.hpp>
+
 SYCL_EXT_ONEAPI_FUNCTION_PROPERTY((syclexp::nd_range_kernel<1>))
 SYCL_EXT_ONEAPI_FUNCTION_PROPERTY((syclexp::work_group_size<32>))
 void iota(float start, float *ptr) {
diff --git a/sycl/doc/extensions/experimental/sycl_ext_oneapi_kernel_properties.asciidoc b/sycl/doc/extensions/experimental/sycl_ext_oneapi_kernel_properties.asciidoc
index 7acc31379f388..07ca2ab0de188 100644
--- a/sycl/doc/extensions/experimental/sycl_ext_oneapi_kernel_properties.asciidoc
+++ b/sycl/doc/extensions/experimental/sycl_ext_oneapi_kernel_properties.asciidoc
@@ -117,33 +117,21 @@ supports.
 
 === Headers
 
-In the current {dpcpp} implementation, the APIs described in this extension
-are organized as follows:
-
-* `#include <sycl/ext/oneapi/kernel_properties.hpp>`
-
-This umbrella header is the most direct choice when code needs property lists
-such as `properties{...}`, embedded kernel properties via `properties_tag`, or
-any of the non-launch kernel properties described in this extension.
-
-The implementation also currently provides lighter-weight headers for code
-that only needs free-function annotations:
-
-* `#include <sycl/ext/oneapi/free_function_kernel_properties.hpp>` for
-  `nd_range_kernel<Dims>`, `single_task_kernel`,
-  `SYCL_EXT_ONEAPI_FUNCTION_PROPERTY`, and the standalone compile-time kernel
-  properties that may be applied directly to a free function declaration, such
-  as `work_group_size`, `work_group_size_hint`, `sub_group_size`,
-  `max_work_group_size`, and `max_linear_work_group_size`.
-
-These lighter-weight headers are primarily intended for code paths where
-reduced compile time is a high priority and the application only needs
-function-level annotations.
-The `sycl/ext/oneapi/free_function_kernel_properties.hpp` header is aimed at
-the free-function kernel definition path. Code that forms property lists or
-uses `properties_tag` will generally find
-`sycl/ext/oneapi/kernel_properties.hpp` to be the more natural header to
-include.
+The APIs defined in this extension are provided by either of the following header files:
+
+* `<sycl/sycl.hpp>`
+* `<sycl/ext/oneapi/kernel_properties.hpp>`
+
+In addition, the following lightweight header provides a subset of the APIs that
+is suitable for applications that define kernels using the
+link:../experimental/sycl_ext_oneapi_free_function_kernels.asciidoc[
+sycl_ext_oneapi_free_function_kernels] extension:
+
+* `<sycl/ext/oneapi/free_function_kernel_properties.hpp>`
+
+This lightweight header provides `SYCL_EXT_ONEAPI_FUNCTION_PROPERTY`, and the properties `work_group_size`, `work_group_size_hint`, `sub_group_size`, `max_work_group_size`, and `max_linear_work_group_size`.
+
+[_Note:_ The lightweight header is intended for cases where kernels are defined using the free-function kernel syntax and fast compilation time is a priority. -- _end note_]
 
 === Kernel Properties
 

From 594d1a4ae9a6974610304281a85ba6abd88e5cc9 Mon Sep 17 00:00:00 2001
From: y <konstantinos.parasyris@intel.com>
Date: Mon, 11 May 2026 08:50:21 -0700
Subject: [PATCH 10/11] Address test coverage comments

---
 .../properties/final_header_include_both.cpp  | 23 +++++--
 .../final_header_include_both_reverse.cpp     | 29 ++++++++
 .../properties/function_properties_split.cpp  | 67 ++++++++++++-------
 .../kernel_properties_header_only.cpp         | 39 +++++++++++
 4 files changed, 126 insertions(+), 32 deletions(-)
 create mode 100644 sycl/test/extensions/properties/final_header_include_both_reverse.cpp
 create mode 100644 sycl/test/extensions/properties/kernel_properties_header_only.cpp

diff --git a/sycl/test/extensions/properties/final_header_include_both.cpp b/sycl/test/extensions/properties/final_header_include_both.cpp
index 78215df980f56..5ffdf46febf6c 100644
--- a/sycl/test/extensions/properties/final_header_include_both.cpp
+++ b/sycl/test/extensions/properties/final_header_include_both.cpp
@@ -3,16 +3,25 @@
 
 #include <sycl/ext/oneapi/free_function_kernel_properties.hpp>
 #include <sycl/ext/oneapi/kernel_properties.hpp>
-#include <sycl/ext/oneapi/properties.hpp>
 
-#include <type_traits>
+namespace syclexp = sycl::ext::oneapi::experimental;
 
-using namespace sycl::ext::oneapi::experimental;
+SYCL_EXT_ONEAPI_FUNCTION_PROPERTY((syclexp::single_task_kernel))
+void SingleTaskKernel();
 
 int main() {
-  static_assert(is_property_value<decltype(single_task_kernel)>::value);
-  static_assert(is_property_value<decltype(work_group_size<2, 3>)>::value);
-  static_assert(std::is_same_v<decltype(properties{work_group_size<1>}),
-                               decltype(properties{work_group_size<1>})>);
+  constexpr auto Props = syclexp::properties{
+      syclexp::work_group_size<1>, syclexp::device_has<sycl::aspect::cpu>};
+
+  static_assert(
+      syclexp::is_property_value<decltype(syclexp::single_task_kernel)>::value);
+  static_assert(
+      syclexp::is_property_value<decltype(syclexp::nd_range_kernel<1>)>::value);
+  static_assert(
+      decltype(Props)::template has_property<syclexp::work_group_size_key>());
+  static_assert(
+      decltype(Props)::template has_property<syclexp::device_has_key>());
+  static_assert(
+      Props.template get_property<syclexp::work_group_size_key>()[0] == 1);
   return 0;
 }
\ No newline at end of file
diff --git a/sycl/test/extensions/properties/final_header_include_both_reverse.cpp b/sycl/test/extensions/properties/final_header_include_both_reverse.cpp
new file mode 100644
index 0000000000000..d7f19673bcea2
--- /dev/null
+++ b/sycl/test/extensions/properties/final_header_include_both_reverse.cpp
@@ -0,0 +1,29 @@
+// RUN: %clangxx -fsycl -fsyntax-only -I %sycl_source_dir/include -I %sycl_include %s
+// expected-no-diagnostics
+
+// clang-format off
+#include <sycl/ext/oneapi/kernel_properties.hpp>
+#include <sycl/ext/oneapi/free_function_kernel_properties.hpp>
+// clang-format on
+
+namespace syclexp = sycl::ext::oneapi::experimental;
+
+SYCL_EXT_ONEAPI_FUNCTION_PROPERTY((syclexp::single_task_kernel))
+void SingleTaskKernel();
+
+int main() {
+  constexpr auto Props = syclexp::properties{
+      syclexp::work_group_size<1>, syclexp::device_has<sycl::aspect::cpu>};
+
+  static_assert(
+      syclexp::is_property_value<decltype(syclexp::single_task_kernel)>::value);
+  static_assert(
+      syclexp::is_property_value<decltype(syclexp::nd_range_kernel<1>)>::value);
+  static_assert(
+      decltype(Props)::template has_property<syclexp::work_group_size_key>());
+  static_assert(
+      decltype(Props)::template has_property<syclexp::device_has_key>());
+  static_assert(
+      Props.template get_property<syclexp::work_group_size_key>()[0] == 1);
+  return 0;
+}
\ No newline at end of file
diff --git a/sycl/test/extensions/properties/function_properties_split.cpp b/sycl/test/extensions/properties/function_properties_split.cpp
index 35cf012cab71d..ff8e3fa510243 100644
--- a/sycl/test/extensions/properties/function_properties_split.cpp
+++ b/sycl/test/extensions/properties/function_properties_split.cpp
@@ -3,37 +3,54 @@
 
 #include <sycl/ext/oneapi/free_function_kernel_properties.hpp>
 
-#include <type_traits>
+namespace syclexp = sycl::ext::oneapi::experimental;
 
-using namespace sycl::ext::oneapi::experimental;
+constexpr size_t WorkGroupX = 2;
+constexpr size_t WorkGroupY = 3;
+constexpr size_t WorkGroupHintX = 4;
+constexpr size_t WorkGroupHintY = 5;
+constexpr size_t WorkGroupHintZ = 6;
+constexpr uint32_t SubGroupSize = 7;
+constexpr size_t MaxWorkGroupX = 8;
+constexpr size_t MaxWorkGroupY = 9;
+constexpr size_t MaxLinearWorkGroupSize = 10;
+
+SYCL_EXT_ONEAPI_FUNCTION_PROPERTY((syclexp::single_task_kernel))
+void SingleTaskKernel();
 
 int main() {
-  static_assert(is_property_value<decltype(nd_range_kernel<1>)>::value);
-  static_assert(is_property_value<decltype(single_task_kernel)>::value);
-  static_assert(is_property_value<decltype(work_group_size<2, 3>)>::value);
   static_assert(
-      is_property_value<decltype(work_group_size_hint<4, 5, 6>)>::value);
-  static_assert(is_property_value<decltype(sub_group_size<7>)>::value);
-  static_assert(is_property_value<decltype(max_work_group_size<8, 9>)>::value);
+      syclexp::is_property_value<decltype(syclexp::nd_range_kernel<1>)>::value);
   static_assert(
-      is_property_value<decltype(max_linear_work_group_size<10>)>::value);
-
-  static_assert(work_group_size<2, 3>[0] == 2);
-  static_assert(work_group_size<2, 3>[1] == 3);
-  static_assert(work_group_size_hint<4, 5, 6>[2] == 6);
-  static_assert(sub_group_size<7>.value == 7);
-  static_assert(max_work_group_size<8, 9>[1] == 9);
-  static_assert(max_linear_work_group_size<10>.value == 10);
+      syclexp::is_property_value<decltype(syclexp::single_task_kernel)>::value);
+  static_assert(
+      syclexp::is_property_value<
+          decltype(syclexp::work_group_size<WorkGroupX, WorkGroupY>)>::value);
+  static_assert(
+      syclexp::is_property_value<
+          decltype(syclexp::work_group_size_hint<WorkGroupHintX, WorkGroupHintY,
+                                                 WorkGroupHintZ>)>::value);
+  static_assert(syclexp::is_property_value<
+                decltype(syclexp::sub_group_size<SubGroupSize>)>::value);
+  static_assert(syclexp::is_property_value<
+                decltype(syclexp::max_work_group_size<MaxWorkGroupX,
+                                                      MaxWorkGroupY>)>::value);
+  static_assert(
+      syclexp::is_property_value<decltype(syclexp::max_linear_work_group_size<
+                                          MaxLinearWorkGroupSize>)>::value);
 
-  static_assert(std::is_same_v<decltype(work_group_size<2, 3>)::key_t,
-                               work_group_size_key>);
-  static_assert(std::is_same_v<decltype(work_group_size_hint<4>)::key_t,
-                               work_group_size_hint_key>);
+  static_assert(syclexp::work_group_size<WorkGroupX, WorkGroupY>[0] ==
+                WorkGroupX);
+  static_assert(syclexp::work_group_size<WorkGroupX, WorkGroupY>[1] ==
+                WorkGroupY);
+  static_assert(syclexp::work_group_size_hint<WorkGroupHintX, WorkGroupHintY,
+                                              WorkGroupHintZ>[2] ==
+                WorkGroupHintZ);
+  static_assert(syclexp::sub_group_size<SubGroupSize>.value == SubGroupSize);
+  static_assert(syclexp::max_work_group_size<MaxWorkGroupX, MaxWorkGroupY>[1] ==
+                MaxWorkGroupY);
   static_assert(
-      std::is_same_v<decltype(sub_group_size<7>)::key_t, sub_group_size_key>);
-  static_assert(std::is_same_v<decltype(max_work_group_size<8>)::key_t,
-                               max_work_group_size_key>);
-  static_assert(std::is_same_v<decltype(max_linear_work_group_size<10>)::key_t,
-                               max_linear_work_group_size_key>);
+      syclexp::max_linear_work_group_size<MaxLinearWorkGroupSize>.value ==
+      MaxLinearWorkGroupSize);
   return 0;
 }
diff --git a/sycl/test/extensions/properties/kernel_properties_header_only.cpp b/sycl/test/extensions/properties/kernel_properties_header_only.cpp
new file mode 100644
index 0000000000000..b822c387f3679
--- /dev/null
+++ b/sycl/test/extensions/properties/kernel_properties_header_only.cpp
@@ -0,0 +1,39 @@
+// RUN: %clangxx -fsycl -fsycl-targets=%sycl_triple -fsyntax-only -I %sycl_source_dir/include -I %sycl_include %s
+// expected-no-diagnostics
+
+#include <sycl/ext/oneapi/kernel_properties.hpp>
+
+namespace syclexp = sycl::ext::oneapi::experimental;
+
+SYCL_EXT_ONEAPI_FUNCTION_PROPERTY((syclexp::nd_range_kernel<1>))
+void NDRangeKernel();
+
+struct KernelFunctor {
+  auto get(syclexp::properties_tag) const {
+    return syclexp::properties{syclexp::work_group_size<4>,
+                               syclexp::device_has<sycl::aspect::cpu>};
+  }
+};
+
+int main() {
+  constexpr auto Props = syclexp::properties{
+      syclexp::work_group_size<2, 3>, syclexp::device_has<sycl::aspect::cpu>};
+
+  static_assert(
+      syclexp::is_property_value<decltype(syclexp::single_task_kernel)>::value);
+  static_assert(
+      syclexp::is_property_value<decltype(syclexp::nd_range_kernel<1>)>::value);
+  static_assert(syclexp::is_property_value<
+                decltype(syclexp::device_has<sycl::aspect::cpu>)>::value);
+  static_assert(
+      decltype(Props)::template has_property<syclexp::work_group_size_key>());
+  static_assert(
+      decltype(Props)::template has_property<syclexp::device_has_key>());
+  static_assert(
+      Props.template get_property<syclexp::work_group_size_key>()[0] == 2);
+  static_assert(
+      Props.template get_property<syclexp::work_group_size_key>()[1] == 3);
+
+  (void)KernelFunctor{}.get(syclexp::properties_tag{});
+  return 0;
+}
\ No newline at end of file

From f40b8734dcd479c14e17c8dd3113a8954db50d42 Mon Sep 17 00:00:00 2001
From: y <konstantinos.parasyris@intel.com>
Date: Tue, 12 May 2026 06:32:19 -0700
Subject: [PATCH 11/11] Fix note

---
 .../sycl_ext_oneapi_free_function_kernels.asciidoc       | 4 +++-
 .../sycl_ext_oneapi_kernel_properties.asciidoc           | 9 +++++++--
 2 files changed, 10 insertions(+), 3 deletions(-)

diff --git a/sycl/doc/extensions/experimental/sycl_ext_oneapi_free_function_kernels.asciidoc b/sycl/doc/extensions/experimental/sycl_ext_oneapi_free_function_kernels.asciidoc
index b887543142ec5..d547fcdeaac88 100644
--- a/sycl/doc/extensions/experimental/sycl_ext_oneapi_free_function_kernels.asciidoc
+++ b/sycl/doc/extensions/experimental/sycl_ext_oneapi_free_function_kernels.asciidoc
@@ -129,7 +129,9 @@ link:../experimental/sycl_ext_oneapi_kernel_properties.asciidoc[
 sycl_ext_oneapi_kernel_properties] for other APIs that are provided by this
 header.
 
-[_Note:_ The lightweight header is intended for cases where fast compilation time is a priority. -- _end note_]
+[_Note:_ The lightweight header is intended for cases where fast compilation 
+time is a priority.
+_{endnote}_]
 
 === Defining a free function kernel
 
diff --git a/sycl/doc/extensions/experimental/sycl_ext_oneapi_kernel_properties.asciidoc b/sycl/doc/extensions/experimental/sycl_ext_oneapi_kernel_properties.asciidoc
index 07ca2ab0de188..c530d65d6fb17 100644
--- a/sycl/doc/extensions/experimental/sycl_ext_oneapi_kernel_properties.asciidoc
+++ b/sycl/doc/extensions/experimental/sycl_ext_oneapi_kernel_properties.asciidoc
@@ -9,6 +9,7 @@
 :encoding: utf-8
 :lang: en
 :dpcpp: pass:[DPC++]
+:endnote: &#8212;{nbsp}end{nbsp}note
 
 :blank: pass:[ +]
 
@@ -129,9 +130,13 @@ sycl_ext_oneapi_free_function_kernels] extension:
 
 * `<sycl/ext/oneapi/free_function_kernel_properties.hpp>`
 
-This lightweight header provides `SYCL_EXT_ONEAPI_FUNCTION_PROPERTY`, and the properties `work_group_size`, `work_group_size_hint`, `sub_group_size`, `max_work_group_size`, and `max_linear_work_group_size`.
+This lightweight header provides `SYCL_EXT_ONEAPI_FUNCTION_PROPERTY`, 
+and the properties `work_group_size`, `work_group_size_hint`, 
+`sub_group_size`, `max_work_group_size`, and `max_linear_work_group_size`.
 
-[_Note:_ The lightweight header is intended for cases where kernels are defined using the free-function kernel syntax and fast compilation time is a priority. -- _end note_]
+[_Note:_ The lightweight header is intended for cases where 
+kernels are defined using the free-function kernel syntax and fast 
+compilation time is a priority._{endnote}_]
 
 === Kernel Properties