[SYCL] Add operator overloading for aggregate types in annotated_ref

[broxigarchen]

Added several operator overloading for aggregate types for annotated_ref class.

This https://godbolt.org/z/h5cTTr17K would be a good example to show why this is not working without this fix.

This PR includes several changes:

1. Propogate operators including all binaries and unary operators, including arithmetic, comparator, and logical.
2. Using perfecting forwarding for binaries operators, compound operators, and unary operators.

This covers cases in which the sequence of conversions will be correct when implicit conversion is involved. i.e

annotated_ref<int> a;
double b;
auto p = a + b; // expected to be (double)a + b, and p should be double

without this fix,

T operator+(T a) const;
annotated_ref<int> a;
double b;
auto p = a + b; // this become a + (int)b, and p will be int

[gmlueck]

Some comments below.

I'd also like @rolandschulz's opinion on whether this is the right way to define the operators.

[rolandschulz]

We should be consistent in how we pass arguments. This won't work with volatile.

[broxigarchen]

We cannot do pass-by-value when A or B is an annotated_ref. The copy constructor of annotated_ref is explicitly marked as deleted. We can only do pass-by-value when A or B are raw types. What do you think?

[rolandschulz]

You're right - I forgot that. I see two options:

1. pass by universal reference. That works for both volatile and ann_ref.
2. go back to 3 seperate overloads for ann_ref+ann_ref, ann_ref+value, value+ann_ref. And pass ann_ref by const& and value by value.

[broxigarchen]

Updated the PR as discussed. Still pending on adding test

[rolandschulz]

"This operator is ..." this sentence is odd for a spec. It just describes how ADL for hidden friends work. Normally we don't explain C++ in the SYCL spec. But maybe a note is warranted because it is non-obvious.

nit: "invoked only" nicer: "participates in overload resolution"

[rolandschulz]

same here: "available only if ...". In both cases it might be clearer if one would say it has lower priority than the other overload (which we achieve by disabling it). But we don't use that wording in other places. @gmlueck which wording do you prefer?

[rolandschulz]

We need more tests:

• test that operators are SFINAE friendly
• test that operators are hidden friends (expected error doesn't contain annotated_ref)
• test that the return value is correct (e.g. decltype(O(a) op std::declval<T>()) or decltype((std::forward<O>(a) op std::declval<T>())) instead of decltype(std::forward<O>(a) op std::declval<T>()))
• test that operators work for a type which doesn't have operators defined but is convertible to a type which does
• that that the operators work if the type has the operators defined in a bad way (e.g. binary operators as members)
• any other corner case we found while prototyping and I forgot in this list

[rolandschulz]

This should be fixed outside this PR. The problem is that both vec (+swizzle) and annotated_arg don't define the their binary operators as hidden friends. For vec the spec is clear that it should be a hidden friend. For annotated_arg we should make this clear.

[broxigarchen]

@intel/llvm-gatekeepers Hi can you help to merge this? The E2E failure seems unrelated. Thanks!