[libcxx] Fix unintended ADL inside ref(reference_wrapper<T>) and cref(reference_wrapper<T>)

[logan-5]

Summary

This patch qualifies calls to ref and cref inside ref(reference_wrapper<T>) and cref(reference_wrapper<T>), respectively. These previously unqualified calls could break in the presence of user functions called ref/cref inside associated namespaces: https://gcc.godbolt.org/z/8VfprT

Fixes https://bugs.llvm.org/show_bug.cgi?id=44398.

Thanks to @Quuxplusone for creating that Godbolt test case and submitting the bug.

[• Quuxplusone]

@logan-5: LGTM! (not that I have any power to commit it).

PR44398 also reports an ADL ref in <memory> https://gcc.godbolt.org/z/EHw3Gy which this patch does not fix, unless I'm missing something.

[logan-5]

In D74287#1865836, @Quuxplusone wrote:

PR44398 also reports an ADL ref in <memory> https://gcc.godbolt.org/z/EHw3Gy which this patch does not fix, unless I'm missing something.

Yep; submitted a fix for that as a separate patch (D74289). :)

[ldionne]

Thanks for the patch!

libcxx/include/__functional_base

ref(_Tp& __t) _NOEXCEPT
     return reference_wrapper<_Tp>(__t);
 }
 
 template <class _Tp>
 inline _LIBCPP_INLINE_VISIBILITY
 reference_wrapper<_Tp>
 ref(reference_wrapper<_Tp> __t) _NOEXCEPT
 {
-    return ref(__t.get());
+    return _VSTD::ref(__t.get());
 }
 
 template <class _Tp>
 inline _LIBCPP_INLINE_VISIBILITY
 reference_wrapper<const _Tp>
 cref(const _Tp& __t) _NOEXCEPT
 {
     return reference_wrapper<const _Tp>(__t);
 }
 
 template <class _Tp>
 inline _LIBCPP_INLINE_VISIBILITY
 reference_wrapper<const _Tp>
 cref(reference_wrapper<_Tp> __t) _NOEXCEPT
 {
-    return cref(__t.get());
+    return _VSTD::cref(__t.get());
 }
 
 #ifndef _LIBCPP_CXX03_LANG
 template <class _Tp> void ref(const _Tp&&) = delete;
 template <class _Tp> void cref(const _Tp&&) = delete;
 #endif
 
 #if _LIBCPP_STD_VER > 11

libcxx/test/std/utilities/function.objects/refwrap/refwrap.helpers/cref_2.pass.cpp

 
 // template <ObjectType T> reference_wrapper<const T> cref(reference_wrapper<T> t);
 
 #include <functional>
 #include <cassert>
 
 #include "test_macros.h"
 
+namespace adl {
+  struct A {};
+  void cref(A) {}
+}
+
 int main(int, char**)
 {
     const int i = 0;
     std::reference_wrapper<const int> r1 = std::cref(i);
     std::reference_wrapper<const int> r2 = std::cref(r1);
     assert(&r2.get() == &i);
 
+    {
+    adl::A a;
+    std::reference_wrapper<const adl::A> a1 = std::cref(a);
+    std::reference_wrapper<const adl::A> a2 = std::cref(a1);
+    assert(&a2.get() == &a);
+    }
+
   return 0;
 }

libcxx/test/std/utilities/function.objects/refwrap/refwrap.helpers/ref_2.pass.cpp

 
 #include "test_macros.h"
 
 bool is5 ( int i ) { return i == 5; }
 
 template <typename T>
 bool call_pred ( T pred ) { return pred(5); }
 
+namespace adl {
+  struct A {};
+  void ref(A) {}
+}
+
 int main(int, char**)
 {
     {
     int i = 0;
     std::reference_wrapper<int> r1 = std::ref(i);
     std::reference_wrapper<int> r2 = std::ref(r1);
     assert(&r2.get() == &i);
     }
     {
+    adl::A a;
+    std::reference_wrapper<adl::A> a1 = std::ref(a);
+    std::reference_wrapper<adl::A> a2 = std::ref(a1);
+    assert(&a2.get() == &a);
+    }
+
+    {
     unary_counting_predicate<bool(*)(int), int> cp(is5);
     assert(!cp(6));
     assert(cp.count() == 1);
     assert(call_pred(cp));
     assert(cp.count() == 1);
     assert(call_pred(std::ref(cp)));
     assert(cp.count() == 2);
     }
 
   return 0;
 }