[SYCL] improve operator forwarding in annotated_ref (#12140)

Consider the following case

```
template <typename T>
class annotated_ref {
    operator T() {}
};

template <typename T>
class A {
    template <typename T2>
    A (T2& p) {}
};

annotated_ref<A> a;
auto b = A(a);  // the operator T() from annotated_ref get shadowed by A's constructor
```

The fix tried to resolve this problem by making operator T() invocation
to be more clear

Author: Brox Chen

sycl/doc/extensions/experimental/sycl_ext_oneapi_annotated_ptr.asciidoc

@@ -617,8 +617,8 @@ T operator=(const annotated_ref& other) const;
 a|
 Equivalent to:
 ```c++
-T tmp = other;   // Reads from memory
-                 // with annotations
+T tmp = other.operator T();   // Reads from memory
+                              // with annotations
 *this = tmp;     // Writes to memory
                  // with annotations
 return T;
@@ -642,8 +642,8 @@ Return result by value.
 Available only if the corresponding assignment operator OP is available for `T` taking a type of `O`.
 Equivalent to:
 ```c++
-T tmp = *this;     // Reads from memory
-                   // with annotations
+T tmp = this->operator T();     // Reads from memory
+                                // with annotations
 tmp OP std::forward<O>(a);
 *this = tmp;       // Writes to memory
                    // with annotations
@@ -665,8 +665,8 @@ Return result by value.
 Available only if the corresponding assignment operator OP is available for `T`.
 Equivalent to:
 ```c++
-T tmp = *this;     // Reads from memory
-                   // with annotations
+T tmp = this->operator T();     // Reads from memory
+                                // with annotations
 T tmp2 = b;        // Reads from memory
                    // with annotations
 tmp OP b;

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

@@ -120,23 +120,23 @@ class annotated_ref<T, detail::properties_t<Props...>> {
 
   template <class O, class P>
   T operator=(const annotated_ref<O, P> &Ref) const {
-    O t2 = Ref;
+    O t2 = Ref.operator O();
     return *this = t2;
   }
 
   // propagate compound operators
 #define PROPAGATE_OP(op)                                                       \
   template <class O, typename = std::enable_if_t<!detail::is_ann_ref_v<O>>>    \
   T operator op(O &&rhs) const {                                               \
-    T t = *this;                                                               \
+    T t = this->operator T();                                                  \
     t op std::forward<O>(rhs);                                                 \
     *this = t;                                                                 \
     return t;                                                                  \
   }                                                                            \
   template <class O, class P>                                                  \
   T operator op(const annotated_ref<O, P> &rhs) const {                        \
-    T t = *this;                                                               \
-    O t2 = rhs;                                                                \
+    T t = this->operator T();                                                  \
+    O t2 = rhs.operator T();                                                   \
     t op t2;                                                                   \
     *this = t;                                                                 \
     return t;                                                                  \
@@ -158,12 +158,12 @@ class annotated_ref<T, detail::properties_t<Props...>> {
   template <class O>                                                           \
   friend auto operator op(O &&a, const annotated_ref &b)                       \
       ->decltype(std::forward<O>(a) op std::declval<T>()) {                    \
-    return std::forward<O>(a) op T(b);                                         \
+    return std::forward<O>(a) op b.operator T();                               \
   }                                                                            \
   template <class O, typename = std::enable_if_t<!detail::is_ann_ref_v<O>>>    \
   friend auto operator op(const annotated_ref &a, O &&b)                       \
       ->decltype(std::declval<T>() op std::forward<O>(b)) {                    \
-    return T(a) op std::forward<O>(b);                                         \
+    return a.operator T() op std::forward<O>(b);                               \
   }
   PROPAGATE_OP(+)
   PROPAGATE_OP(-)
@@ -190,7 +190,7 @@ class annotated_ref<T, detail::properties_t<Props...>> {
 #define PROPAGATE_OP(op)                                                       \
   template <typename O = T>                                                    \
   auto operator op() const->decltype(op std::declval<O>()) {                   \
-    return op O(*this);                                                        \
+    return op this->operator O();                                              \
   }
   PROPAGATE_OP(+)
   PROPAGATE_OP(-)
@@ -200,29 +200,29 @@ class annotated_ref<T, detail::properties_t<Props...>> {
 
   // Propagate inc/dec operators
   T operator++() const {
-    T t = *this;
+    T t = this->operator T();
     ++t;
     *this = t;
     return t;
   }
 
   T operator++(int) const {
-    T t1 = *this;
+    T t1 = this->operator T();
     T t2 = t1;
     t2++;
     *this = t2;
     return t1;
   }
 
   T operator--() const {
-    T t = *this;
+    T t = this->operator T();
     --t;
     *this = t;
     return t;
   }
 
   T operator--(int) const {
-    T t1 = *this;
+    T t1 = this->operator T();
     T t2 = t1;
     t2--;
     *this = t2;

sycl/test-e2e/Annotated_arg_ptr/annotated_ptr.cpp

@@ -67,6 +67,17 @@ template <typename T> struct MyThirdStruct {
   float operator==(const T &rhs) const { return data == rhs.data ? 3.0 : 1.0; }
 };
 
+template <typename T> struct MyFourthStruct {
+  T p;
+
+  template <typename T2> MyFourthStruct(const T2 &p_) : p(p_) {}
+
+  template <typename T2> void operator=(const T2 &p_) {}
+
+  int operator+(const int &rhs) const { return 0; }
+  int operator+=(const int &rhs) const { return 0; }
+};
+
 MySecondStruct::operator MyStruct<int>() const { return MyStruct<int>(0); }
 
 #define BINARY_OP(op)                                                          \
@@ -181,6 +192,11 @@ int main() {
 
   auto *r10 = malloc_shared<int>(1, Q);
 
+  auto *r11 = malloc_shared<MyFourthStruct<int>>(1, Q);
+  annotated_ptr r11_ptr{r11};
+  auto r11_add = *r11_ptr + 1;
+  *r11_ptr += 1;
+
   // testing return type of operators
   int o1 = 0;
   float o2 = 1.5;