update spec and annotated_ptr for void type

Author: Chen, Brox

sycl/doc/extensions/experimental/sycl_ext_oneapi_annotated_ptr.asciidoc

@@ -193,15 +193,20 @@ struct MyType {
 };
 
 struct MyKernel {
-  annotated_ptr<MyType, properties<PropA>> a; //non-trivially-copyable type
+  annotated_ptr<MyType, properties<PropA>> a; //non-trivially-copyable type is not allowed
+  annotated_ptr<void, properties<PropB>> b;   //void is legal 
   ...
   void operator()() const {
     ...
+    *b = ...; //deference is not allowed
   }
 };
 ----
-It is illegal to apply `annotated_ptr` to a non-trivially-copyable type `T`. In the
-above example, encapsulating `annotated_ptr` within `MyType` is illegal.
+It is ill-formed to instantiate`annotated_ptr` and `annotated_ref` for a non-trivially-copyable
+type `T`. The only exception is that `annotated_ptr` is allowed to be instantiated with `void`.
+
+In the above example, encapsulating `annotated_ptr` within `MyType` is illegal. Encapsulating
+`annotated_ptr` with `void` is legal, but it can not be deferenced.
 
 [source,c++]
 ----

sycl/include/sycl/ext/oneapi/experimental/annotated_ptr/annotated_ptr.hpp

@@ -78,6 +78,10 @@ template <typename T, typename... Props>
 class annotated_ref<T, detail::properties_t<Props...>> {
   using property_list_t = detail::properties_t<Props...>;
 
+  static_assert(
+      std::is_trivially_copyable_v<T>,
+      "annotated_ref can only be encapsulated with trivially-copyable type!");
+
 private:
   T *m_Ptr;
   annotated_ref(T *Ptr) : m_Ptr(Ptr) {}
@@ -178,6 +182,11 @@ class __SYCL_SPECIAL_CLASS
 __SYCL_TYPE(annotated_ptr) annotated_ptr<T, detail::properties_t<Props...>> {
   using property_list_t = detail::properties_t<Props...>;
 
+  static_assert(
+      std::is_same_v<T, void> || std::is_trivially_copyable_v<T>,
+      "annotated_ptr can only be encapsulated with either trivially-copyable type "
+      "or void!");
+
   // buffer_location and alignment are allowed for annotated_ref
   // Cache controls are allowed for annotated_ptr
   using allowed_properties =
@@ -238,11 +247,6 @@ __SYCL_TYPE(annotated_ptr) annotated_ptr<T, detail::properties_t<Props...>> {
   annotated_ptr(const annotated_ptr &) = default;
   annotated_ptr &operator=(const annotated_ptr &) = default;
 
-  static_assert(
-      std::is_same_v<T, void> || std::is_trivially_copyable_v<T>,
-      "encapsulating annotated_ptr with non-trivially-copyable type is "
-      "not supported!");
-
   explicit annotated_ptr(T *Ptr,
                          const property_list_t & = properties{}) noexcept
       : m_Ptr(Ptr) {}