[C++4OpenCL] call to 'forward' is ambiguous when used inside lambda

[biggysmith]

Hi,

I'm getting a error: call to 'forward' is ambiguous when trying to compile a kernel that forwards variadic arguments

template<typename... T>
void func2(T&&... t){
}

kernel void test(                  
    __write_only image2d_t dst_img,
    __read_only image3d_t src_img
)                      
{     
    // call to forward is ambigous
    auto lambda = [](auto&&... arg) {
        func2(forward<decltype(arg)>(arg)...);
    };
          
    lambda(dst_img,src_img);  
} 

godbolt example here

It works in regular C++, but I think address spaces might be confusing it here in OpenCL.

[llvmbot]

@llvm/issue-subscribers-opencl

Hi,

I'm getting a error: call to 'forward' is ambiguous when trying to compile a kernel that forwards variadic arguments

template<typename... T>
void func2(T&&... t){
}

kernel void test(                  
    __write_only image2d_t dst_img,
    __read_only image3d_t src_img
)                      
{     
    // call to forward is ambigous
    auto lambda = [](auto&&... arg) {
        func2(forward<decltype(arg)>(arg)...);
    };
          
    lambda(dst_img,src_img);  
} 

godbolt example here

It works in regular C++, but I think address spaces might be confusing it here in OpenCL.

[piotrrak]

It seems to be the problem with __remove_reference transform traits builtin, as I can reproduce it on trunk but no any longer with #153508 applied.

[piotrrak]

It seems to be the problem with __remove_reference transform traits builtin, as I can reproduce it on trunk but no any longer with #153508 applied.

Never mind that - this should be rejects invalid:
My change couldn't fix that; though what I tested locally was with:

template <typename T> using remote_reference_t = __remove_reference_t(T);

Which was real solution to the issue, as there is no definition of struct std::remove_reference here.

The diagnostics we got though is misleading to say at least, I'll keep this in mind and investigate what went wrong there some time later.

https://godbolt.org/z/zPsqbhce8

[piotrrak]

I keep getting this wrong and wrong again, original code in compiler explorer has definition of struct remove_reference thus it is still rejects valid;
Anyway the issue boils down to the difference between:

template<typename T>
struct remove_reference { 
    using type = T;
};

template<typename T>
struct remove_reference<T&> { 
    using type = T;
};

template<typename T>
struct remove_reference<T&&> { 
    using type = T;
};

vs

template<typename T>
using remove_reference_t = __remove_reference_t(T);

[piotrrak]

Playing with it bit more:

template<typename T>
struct remove_reference;
// { 
//    using type = T;
//};

//template<typename T>
//struct remove_reference<T&> { 
//    using type = T;
//};

template<typename T>
struct remove_reference<T &> { 
    using type = T;
};

//template<typename T>
//struct remove_reference<T&&> { 
//    using type = T;
//};

template<typename T>
struct remove_reference_tt {
    using type = __remove_reference_t(T);
};

template<typename T>
using remove_reference_t1 = typename remove_reference<T>::type;

template<typename T>
using remove_reference_t2 = typename remove_reference_tt<T>::type;

template<typename T>
using remove_reference_t3 = __remove_reference_t(T);

kernel void test(                  
    __read_only image2d_t dst_img,
    __write_only image3d_t src_img
)                      
{
#if 0
    static_assert(__is_same(remove_reference_t1<decltype(dst_img)>,
                            remove_reference_t2<decltype(dst_img)>) and
                  __is_same(remove_reference_t2<decltype(dst_img)>,
                             remove_reference_t3<decltype(dst_img)>));
#endif     
    auto lambda = [](auto&&... arg) {
        static_assert(((__is_same(remove_reference_t1<decltype(arg)>,
                                   remove_reference_t2<decltype(arg)>) and
                         __is_same(remove_reference_t2<decltype(arg)>,
                                   remove_reference_t3<decltype(arg)>)) && ...));
    };
          
    lambda(dst_img);  
}

<source>:30:1: error: implicit instantiation of undefined template 'remove_reference<__private __read_only image2d_t &__private>'
   30 | using remove_reference_t1 = typename remove_reference<T>::type;
      | ^
<source>:50:35: note: in instantiation of template type alias 'remove_reference_t1' requested here
   50 |         static_assert(((__is_same(remove_reference_t1<decltype(arg)>,
      |                                   ^
<source>:56:11: note: in instantiation of function template specialization 'test(__private __read_only image2d_t, __private __write_only image3d_t)::(anonymous class)::operator()<__private __read_only image2d_t &>' requested here
   56 |     lambda(dst_img);  
      |           ^
<source>:4:8: note: template is declared here
    4 | struct remove_reference;
      |        ^
1 error generated.

We simply end up choosing default template instead of specialization for lvalue.
But looking at AST I am not sure anymore if it possible to express such specialization in OpenCLC++.

https://godbolt.org/z/316c3YEqW

But that's fine, I am new to AS qualifiers game and still see types with combination of qualifiers I can't imagine or are not expressible at all. Will keep digging.